﻿ 


using System.Runtime.Serialization;
using System;
using RestAPICore;
using System.Linq;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Threading;
using System.IO;
using System.Collections.ObjectModel;
using System.ComponentModel;
namespace SinaWeiboClientV1
{





	public partial class WeiboClient:JsonClientBase
	{
		public WeiboClient()
		{
			//TODO: Set BaseUri property Here 在这里指定服务基础地址
			BaseUri = new Uri("http://api.t.sina.com.cn");
					
			_executeEmotionsMethod= new JsonMethod<Emotions.Request, Emotions.Response>(this, new Uri("emotions.json", UriKind.Relative));
						
			_executeFavoritesMethod= new JsonMethod<Favorites.Request, Favorites.Response>(this, new Uri("favorites.json", UriKind.Relative));
						
			_executeAccountEndSessionMethod= new JsonMethod<Account.EndSession.Request, Account.EndSession.Response>(this, new Uri("account/end_session.json", UriKind.Relative));
						
			_executeAccountGetPrivacyMethod= new JsonMethod<Account.GetPrivacy.Request, Account.GetPrivacy.Response>(this, new Uri("account/get_privacy.json", UriKind.Relative));
						
			_executeAccountRateLimitStatusMethod= new JsonMethod<Account.RateLimitStatus.Request, Account.RateLimitStatus.Response>(this, new Uri("account/rate_limit_status.json", UriKind.Relative));
						
			_executeAccountUpdateProfileMethod= new JsonMethod<Account.UpdateProfile.Request, Account.UpdateProfile.Response>(this, new Uri("account/update_profile.json", UriKind.Relative));
						
			_executeAccountUpdateProfileImageMethod= new JsonMethod<Account.UpdateProfileImage.Request, Account.UpdateProfileImage.Response>(this, new Uri("account/update_profile_image.json", UriKind.Relative));
						
			_executeAccountVerifyCredentialsMethod= new JsonMethod<Account.VerifyCredentials.Request, Account.VerifyCredentials.Response>(this, new Uri("account/verify_credentials.json", UriKind.Relative));
						
			_executeBlocksBlockingMethod= new JsonMethod<Blocks.Blocking.Request, Blocks.Blocking.Response>(this, new Uri("blocks/blocking.json", UriKind.Relative));
						
			_executeBlocksCreateMethod= new JsonMethod<Blocks.Create.Request, Blocks.Create.Response>(this, new Uri("blocks/create.json", UriKind.Relative));
						
			_executeBlocksDestroyMethod= new JsonMethod<Blocks.Destroy.Request, Blocks.Destroy.Response>(this, new Uri("blocks/destroy.json", UriKind.Relative));
						
			_executeBlocksExistsMethod= new JsonMethod<Blocks.Exists.Request, Blocks.Exists.Response>(this, new Uri("blocks/exists.json", UriKind.Relative));
						
			_executeFavoritesCreateMethod= new JsonMethod<Favorites.Create.Request, Favorites.Create.Response>(this, new Uri("favorites/create.json", UriKind.Relative));
						
			_executeFavoritesDestroyMethod= new JsonMethod<Favorites.Destroy.Request, Favorites.Destroy.Response>(this, new Uri("favorites/destroy/{id}.json", UriKind.Relative));
						
			_executeFavoritesDestroyBatchMethod= new JsonMethod<Favorites.DestroyBatch.Request, Favorites.DestroyBatch.Response>(this, new Uri("favorites/destroy_batch.json", UriKind.Relative));
						
			_executeFriendshipsCreateMethod= new JsonMethod<Friendships.Create.Request, Friendships.Create.Response>(this, new Uri("friendships/create/{id}.json", UriKind.Relative));
						
			_executeFriendshipsDestroyMethod= new JsonMethod<Friendships.Destroy.Request, Friendships.Destroy.Response>(this, new Uri("friendships/destroy/{id}.json", UriKind.Relative));
						
			_executeFriendshipsExistsMethod= new JsonMethod<Friendships.Exists.Request, Friendships.Exists.Response>(this, new Uri("friendships/exists.json", UriKind.Relative));
						
			_executeFriendshipsShowMethod= new JsonMethod<Friendships.Show.Request, Friendships.Show.Response>(this, new Uri("friendships/show.json", UriKind.Relative));
						
			_executeShortUrlExpandMethod= new JsonMethod<ShortUrl.Expand.Request, ShortUrl.Expand.Response>(this, new Uri("short_url/expand.json", UriKind.Relative));
						
			_executeShortUrlShortenMethod= new JsonMethod<ShortUrl.Shorten.Request, ShortUrl.Shorten.Response>(this, new Uri("short_url/shorten.json", UriKind.Relative));
						
			_executeShortUrlCommentCommentsMethod= new JsonMethod<ShortUrl.Comment.Comments.Request, ShortUrl.Comment.Comments.Response>(this, new Uri("short_url/comment/comments.json", UriKind.Relative));
						
			_executeShortUrlCommentCountsMethod= new JsonMethod<ShortUrl.Comment.Counts.Request, ShortUrl.Comment.Counts.Response>(this, new Uri("short_url/comment/counts.json", UriKind.Relative));
						
			_executeShortUrlShareCountsMethod= new JsonMethod<ShortUrl.Share.Counts.Request, ShortUrl.Share.Counts.Response>(this, new Uri("short_url/share/counts.json", UriKind.Relative));
						
			_executeShortUrlShareStatusesMethod= new JsonMethod<ShortUrl.Share.Statuses.Request, ShortUrl.Share.Statuses.Response>(this, new Uri("short_url/share/statuses.json", UriKind.Relative));
						
			_executeStatusesCommentMethod= new JsonMethod<Statuses.Comment.Request, Statuses.Comment.Response>(this, new Uri("statuses/comment.json", UriKind.Relative));
						
			_executeStatusesCommentsByMeMethod= new JsonMethod<Statuses.CommentsByMe.Request, Statuses.CommentsByMe.Response>(this, new Uri("statuses/comments_by_me.json", UriKind.Relative));
						
			_executeStatusesCommentsTimelineMethod= new JsonMethod<Statuses.CommentsTimeline.Request, Statuses.CommentsTimeline.Response>(this, new Uri("statuses/comments_timeline.json", UriKind.Relative));
						
			_executeStatusesCommentsToMeMethod= new JsonMethod<Statuses.CommentsToMe.Request, Statuses.CommentsToMe.Response>(this, new Uri("statuses/comments_to_me.json", UriKind.Relative));
						
			_executeStatusesCommentDestroyMethod= new JsonMethod<Statuses.CommentDestroy.Request, Statuses.CommentDestroy.Response>(this, new Uri("statuses/comment_destroy/{id}.json", UriKind.Relative));
						
			_executeStatusesCommentDestroyBatchMethod= new JsonMethod<Statuses.CommentDestroyBatch.Request, Statuses.CommentDestroyBatch.Response>(this, new Uri("statuses/comment/destroy_batch.json", UriKind.Relative));
						
			_executeStatusesCountsMethod= new JsonMethod<Statuses.Counts.Request, Statuses.Counts.Response>(this, new Uri("statuses/counts.json", UriKind.Relative));
						
			_executeStatusesFollowersMethod= new JsonMethod<Statuses.Followers.Request, Statuses.Followers.Response>(this, new Uri("statuses/followers.json", UriKind.Relative));
						
			_executeStatusesFriendsMethod= new JsonMethod<Statuses.Friends.Request, Statuses.Friends.Response>(this, new Uri("statuses/friends.json", UriKind.Relative));
						
			_executeStatusesFriendsTimelineMethod= new JsonMethod<Statuses.FriendsTimeline.Request, Statuses.FriendsTimeline.Response>(this, new Uri("statuses/friends_timeline.json", UriKind.Relative));
						
			_executeStatusesPublicTimelineMethod= new JsonMethod<Statuses.PublicTimeline.Request, Statuses.PublicTimeline.Response>(this, new Uri("statuses/public_timeline.json", UriKind.Relative));
						
			_executeStatusesReplyMethod= new JsonMethod<Statuses.Reply.Request, Statuses.Reply.Response>(this, new Uri("statuses/reply.json", UriKind.Relative));
						
			_executeStatusesRepostMethod= new JsonMethod<Statuses.Repost.Request, Statuses.Repost.Response>(this, new Uri("statuses/repost.json", UriKind.Relative));
						
			_executeStatusesRepostByMeMethod= new JsonMethod<Statuses.RepostByMe.Request, Statuses.RepostByMe.Response>(this, new Uri("statuses/repost_by_me.json", UriKind.Relative));
						
			_executeStatusesResetCountMethod= new JsonMethod<Statuses.ResetCount.Request, Statuses.ResetCount.Response>(this, new Uri("statuses/reset_count.json", UriKind.Relative));
						
			_executeStatusesShowMethod= new JsonMethod<Statuses.Show.Request, Statuses.Show.Response>(this, new Uri("statuses/show/{id}.json", UriKind.Relative));
						
			_executeStatusesUnreadMethod= new JsonMethod<Statuses.Unread.Request, Statuses.Unread.Response>(this, new Uri("statuses/unread.json", UriKind.Relative));
						
			_executeStatusesUpdateMethod= new JsonMethod<Statuses.Update.Request, Statuses.Update.Response>(this, new Uri("statuses/update.json", UriKind.Relative));
						
			_executeStatusesUploadMethod= new JsonMethod<Statuses.Upload.Request, Statuses.Upload.Response>(this, new Uri("statuses/upload.json", UriKind.Relative));
						
			_executeStatusesUserTimelineMethod= new JsonMethod<Statuses.UserTimeline.Request, Statuses.UserTimeline.Response>(this, new Uri("statuses/user_timeline/{id}.json", UriKind.Relative));
						
			_executeTagsCreateMethod= new JsonMethod<Tags.Create.Request, Tags.Create.Response>(this, new Uri("tags/create.json", UriKind.Relative));
						
			_executeTagsSuggestionsMethod= new JsonMethod<Tags.Suggestions.Request, Tags.Suggestions.Response>(this, new Uri("tags/suggestions.json", UriKind.Relative));
						
			_executeTrendsFollowMethod= new JsonMethod<Trends.Follow.Request, Trends.Follow.Response>(this, new Uri("trends/follow.json", UriKind.Relative));
						
			_executeTrendsStatusesMethod= new JsonMethod<Trends.Statuses.Request, Trends.Statuses.Response>(this, new Uri("trends/statuses.json", UriKind.Relative));
						
			_executeTrendsTrendsMethod= new JsonMethod<Trends.Trends.Request, Trends.Trends.Response>(this, new Uri("trends.json", UriKind.Relative));
						
			_executeUserFriendsUpdateRemarkMethod= new JsonMethod<User.Friends.UpdateRemark.Request, User.Friends.UpdateRemark.Response>(this, new Uri("user/friends/update_remark.json", UriKind.Relative));
						
			_executeUsersHotMethod= new JsonMethod<Users.Hot.Request, Users.Hot.Response>(this, new Uri("users/hot.json", UriKind.Relative));
						
			_executeUsersShowMethod= new JsonMethod<Users.Show.Request, Users.Show.Response>(this, new Uri("users/show/{id}.json", UriKind.Relative));
						
					
			_requestEmotionsMethod= new JsonMethod<Emotions.Request, Stream>(this, new Uri("emotions.json", UriKind.Relative));
						
			_requestFavoritesMethod= new JsonMethod<Favorites.Request, Stream>(this, new Uri("favorites.json", UriKind.Relative));
						
			_requestAccountEndSessionMethod= new JsonMethod<Account.EndSession.Request, Stream>(this, new Uri("account/end_session.json", UriKind.Relative));
						
			_requestAccountGetPrivacyMethod= new JsonMethod<Account.GetPrivacy.Request, Stream>(this, new Uri("account/get_privacy.json", UriKind.Relative));
						
			_requestAccountRateLimitStatusMethod= new JsonMethod<Account.RateLimitStatus.Request, Stream>(this, new Uri("account/rate_limit_status.json", UriKind.Relative));
						
			_requestAccountUpdatePrivacyMethod= new JsonMethod<Account.UpdatePrivacy.Request, Stream>(this, new Uri("account/update_privacy.json", UriKind.Relative));
						
			_requestAccountUpdateProfileMethod= new JsonMethod<Account.UpdateProfile.Request, Stream>(this, new Uri("account/update_profile.json", UriKind.Relative));
						
			_requestAccountUpdateProfileImageMethod= new JsonMethod<Account.UpdateProfileImage.Request, Stream>(this, new Uri("account/update_profile_image.json", UriKind.Relative));
						
			_requestAccountVerifyCredentialsMethod= new JsonMethod<Account.VerifyCredentials.Request, Stream>(this, new Uri("account/verify_credentials.json", UriKind.Relative));
						
			_requestBlocksBlockingMethod= new JsonMethod<Blocks.Blocking.Request, Stream>(this, new Uri("blocks/blocking.json", UriKind.Relative));
						
			_requestBlocksBlockingIdsMethod= new JsonMethod<Blocks.BlockingIds.Request, Stream>(this, new Uri("blocks/blocking/ids.json", UriKind.Relative));
						
			_requestBlocksCreateMethod= new JsonMethod<Blocks.Create.Request, Stream>(this, new Uri("blocks/create.json", UriKind.Relative));
						
			_requestBlocksDestroyMethod= new JsonMethod<Blocks.Destroy.Request, Stream>(this, new Uri("blocks/destroy.json", UriKind.Relative));
						
			_requestBlocksExistsMethod= new JsonMethod<Blocks.Exists.Request, Stream>(this, new Uri("blocks/exists.json", UriKind.Relative));
						
			_requestFavoritesCreateMethod= new JsonMethod<Favorites.Create.Request, Stream>(this, new Uri("favorites/create.json", UriKind.Relative));
						
			_requestFavoritesDestroyMethod= new JsonMethod<Favorites.Destroy.Request, Stream>(this, new Uri("favorites/destroy/{id}.json", UriKind.Relative));
						
			_requestFavoritesDestroyBatchMethod= new JsonMethod<Favorites.DestroyBatch.Request, Stream>(this, new Uri("favorites/destroy_batch.json", UriKind.Relative));
						
			_requestFriendshipsCreateMethod= new JsonMethod<Friendships.Create.Request, Stream>(this, new Uri("friendships/create/{id}.json", UriKind.Relative));
						
			_requestFriendshipsDestroyMethod= new JsonMethod<Friendships.Destroy.Request, Stream>(this, new Uri("friendships/destroy/{id}.json", UriKind.Relative));
						
			_requestFriendshipsExistsMethod= new JsonMethod<Friendships.Exists.Request, Stream>(this, new Uri("friendships/exists.json", UriKind.Relative));
						
			_requestFriendshipsShowMethod= new JsonMethod<Friendships.Show.Request, Stream>(this, new Uri("friendships/show.json", UriKind.Relative));
						
			_requestShortUrlExpandMethod= new JsonMethod<ShortUrl.Expand.Request, Stream>(this, new Uri("short_url/expand.json", UriKind.Relative));
						
			_requestShortUrlShortenMethod= new JsonMethod<ShortUrl.Shorten.Request, Stream>(this, new Uri("short_url/shorten.json", UriKind.Relative));
						
			_requestShortUrlCommentCommentsMethod= new JsonMethod<ShortUrl.Comment.Comments.Request, Stream>(this, new Uri("short_url/comment/comments.json", UriKind.Relative));
						
			_requestShortUrlCommentCountsMethod= new JsonMethod<ShortUrl.Comment.Counts.Request, Stream>(this, new Uri("short_url/comment/counts.json", UriKind.Relative));
						
			_requestShortUrlShareCountsMethod= new JsonMethod<ShortUrl.Share.Counts.Request, Stream>(this, new Uri("short_url/share/counts.json", UriKind.Relative));
						
			_requestShortUrlShareStatusesMethod= new JsonMethod<ShortUrl.Share.Statuses.Request, Stream>(this, new Uri("short_url/share/statuses.json", UriKind.Relative));
						
			_requestSocialgraphFollowsIdsMethod= new JsonMethod<Socialgraph.FollowsIds.Request, Stream>(this, new Uri("followers/ids/{id}.json", UriKind.Relative));
						
			_requestSocialgraphFriendsIdsMethod= new JsonMethod<Socialgraph.FriendsIds.Request, Stream>(this, new Uri("friends/ids/{id}.json", UriKind.Relative));
						
			_requestStatusesCommentMethod= new JsonMethod<Statuses.Comment.Request, Stream>(this, new Uri("statuses/comment.json", UriKind.Relative));
						
			_requestStatusesCommentsMethod= new JsonMethod<Statuses.Comments.Request, Stream>(this, new Uri("statuses/comments.json", UriKind.Relative));
						
			_requestStatusesCommentsByMeMethod= new JsonMethod<Statuses.CommentsByMe.Request, Stream>(this, new Uri("statuses/comments_by_me.json", UriKind.Relative));
						
			_requestStatusesCommentsTimelineMethod= new JsonMethod<Statuses.CommentsTimeline.Request, Stream>(this, new Uri("statuses/comments_timeline.json", UriKind.Relative));
						
			_requestStatusesCommentsToMeMethod= new JsonMethod<Statuses.CommentsToMe.Request, Stream>(this, new Uri("statuses/comments_to_me.json", UriKind.Relative));
						
			_requestStatusesCommentDestroyMethod= new JsonMethod<Statuses.CommentDestroy.Request, Stream>(this, new Uri("statuses/comment_destroy/{id}.json", UriKind.Relative));
						
			_requestStatusesCommentDestroyBatchMethod= new JsonMethod<Statuses.CommentDestroyBatch.Request, Stream>(this, new Uri("statuses/comment/destroy_batch.json", UriKind.Relative));
						
			_requestStatusesCountsMethod= new JsonMethod<Statuses.Counts.Request, Stream>(this, new Uri("statuses/counts.json", UriKind.Relative));
						
			_requestStatusesDestroyMethod= new JsonMethod<Statuses.Destroy.Request, Stream>(this, new Uri("statuses/destroy/{id}.json", UriKind.Relative));
						
			_requestStatusesFollowersMethod= new JsonMethod<Statuses.Followers.Request, Stream>(this, new Uri("statuses/followers.json", UriKind.Relative));
						
			_requestStatusesFriendsMethod= new JsonMethod<Statuses.Friends.Request, Stream>(this, new Uri("statuses/friends.json", UriKind.Relative));
						
			_requestStatusesFriendsTimelineMethod= new JsonMethod<Statuses.FriendsTimeline.Request, Stream>(this, new Uri("statuses/friends_timeline.json", UriKind.Relative));
						
			_requestStatusesMentionsMethod= new JsonMethod<Statuses.Mentions.Request, Stream>(this, new Uri("statuses/mentions.json", UriKind.Relative));
						
			_requestStatusesPublicTimelineMethod= new JsonMethod<Statuses.PublicTimeline.Request, Stream>(this, new Uri("statuses/public_timeline.json", UriKind.Relative));
						
			_requestStatusesReplyMethod= new JsonMethod<Statuses.Reply.Request, Stream>(this, new Uri("statuses/reply.json", UriKind.Relative));
						
			_requestStatusesRepostMethod= new JsonMethod<Statuses.Repost.Request, Stream>(this, new Uri("statuses/repost.json", UriKind.Relative));
						
			_requestStatusesRepostByMeMethod= new JsonMethod<Statuses.RepostByMe.Request, Stream>(this, new Uri("statuses/repost_by_me.json", UriKind.Relative));
						
			_requestStatusesRepostTimelineMethod= new JsonMethod<Statuses.RepostTimeline.Request, Stream>(this, new Uri("statuses/repost_timeline.json", UriKind.Relative));
						
			_requestStatusesResetCountMethod= new JsonMethod<Statuses.ResetCount.Request, Stream>(this, new Uri("statuses/reset_count.json", UriKind.Relative));
						
			_requestStatusesShowMethod= new JsonMethod<Statuses.Show.Request, Stream>(this, new Uri("statuses/show/{id}.json", UriKind.Relative));
						
			_requestStatusesUnreadMethod= new JsonMethod<Statuses.Unread.Request, Stream>(this, new Uri("statuses/unread.json", UriKind.Relative));
						
			_requestStatusesUpdateMethod= new JsonMethod<Statuses.Update.Request, Stream>(this, new Uri("statuses/update.json", UriKind.Relative));
						
			_requestStatusesUploadMethod= new JsonMethod<Statuses.Upload.Request, Stream>(this, new Uri("statuses/upload.json", UriKind.Relative));
						
			_requestStatusesUserTimelineMethod= new JsonMethod<Statuses.UserTimeline.Request, Stream>(this, new Uri("statuses/user_timeline/{id}.json", UriKind.Relative));
						
			_requestTagsCreateMethod= new JsonMethod<Tags.Create.Request, Stream>(this, new Uri("tags/create.json", UriKind.Relative));
						
			_requestTagsDestroyMethod= new JsonMethod<Tags.Destroy.Request, Stream>(this, new Uri("tags/destroy.json", UriKind.Relative));
						
			_requestTagsDestroyBatchMethod= new JsonMethod<Tags.DestroyBatch.Request, Stream>(this, new Uri("tags/destroy_batch.json", UriKind.Relative));
						
			_requestTagsSuggestionsMethod= new JsonMethod<Tags.Suggestions.Request, Stream>(this, new Uri("tags/suggestions.json", UriKind.Relative));
						
			_requestTagsTagsMethod= new JsonMethod<Tags.Tags.Request, Stream>(this, new Uri("tags.json", UriKind.Relative));
						
			_requestTrendsDailyMethod= new JsonMethod<Trends.Daily.Request, Stream>(this, new Uri("trends/daily.json", UriKind.Relative));
						
			_requestTrendsDestroyMethod= new JsonMethod<Trends.Destroy.Request, Stream>(this, new Uri("trends/destroy.json", UriKind.Relative));
						
			_requestTrendsFollowMethod= new JsonMethod<Trends.Follow.Request, Stream>(this, new Uri("trends/follow.json", UriKind.Relative));
						
			_requestTrendsHourlyMethod= new JsonMethod<Trends.Hourly.Request, Stream>(this, new Uri("trends/hourly.json", UriKind.Relative));
						
			_requestTrendsStatusesMethod= new JsonMethod<Trends.Statuses.Request, Stream>(this, new Uri("trends/statuses.json", UriKind.Relative));
						
			_requestTrendsTrendsMethod= new JsonMethod<Trends.Trends.Request, Stream>(this, new Uri("trends.json", UriKind.Relative));
						
			_requestTrendsWeeklyMethod= new JsonMethod<Trends.Weekly.Request, Stream>(this, new Uri("trends/weekly.json", UriKind.Relative));
						
			_requestUserFriendsUpdateRemarkMethod= new JsonMethod<User.Friends.UpdateRemark.Request, Stream>(this, new Uri("user/friends/update_remark.json", UriKind.Relative));
						
			_requestUsersHotMethod= new JsonMethod<Users.Hot.Request, Stream>(this, new Uri("users/hot.json", UriKind.Relative));
						
			_requestUsersShowMethod= new JsonMethod<Users.Show.Request, Stream>(this, new Uri("users/show/{id}.json", UriKind.Relative));
						
			_requestUsersSuggestionsMethod= new JsonMethod<Users.Suggestions.Request, Stream>(this, new Uri("users/suggestions.json", UriKind.Relative));
					}
		
				
		/// <summary>
		/// Path\emotions
		/// </summary>
		JsonMethod<Emotions.Request, Emotions.Response> _executeEmotionsMethod;
		
		/// <summary>
		/// This is a async execution of \emotions rest call. 
		/// It returns JsonResponse&lt;Emotions.Response&gt;
		/// Here comes request Comments:
		///<para>返回新浪微博官方所有表情、魔法表情的相关信息。包括短语、表情类型、表情分类，是否热门等。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/emotions.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	false  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	false  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Emotions.Response>> ExecuteEmotionsAsync (
			Emotions.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeEmotionsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \emotions rest call. 
		/// It returns JsonResponse&lt;Emotions.Response&gt;
		/// Here comes request Comments:
		///<para>返回新浪微博官方所有表情、魔法表情的相关信息。包括短语、表情类型、表情分类，是否热门等。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/emotions.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	false  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	false  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Emotions.Response> ExecuteEmotions(Emotions.Request request)
		{
			return ExecuteEmotionsAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\favorites
		/// </summary>
		JsonMethod<Favorites.Request, Favorites.Response> _executeFavoritesMethod;
		
		/// <summary>
		/// This is a async execution of \favorites rest call. 
		/// It returns JsonResponse&lt;Favorites.Response&gt;
		/// Here comes request Comments:
		///<para>返回登录用户最近收藏的20条微博消息，和用户在主站上“我的收藏”页面看到的内容是一致的。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/favorites.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Favorites.Response>> ExecuteFavoritesAsync (
			Favorites.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeFavoritesMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \favorites rest call. 
		/// It returns JsonResponse&lt;Favorites.Response&gt;
		/// Here comes request Comments:
		///<para>返回登录用户最近收藏的20条微博消息，和用户在主站上“我的收藏”页面看到的内容是一致的。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/favorites.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Favorites.Response> ExecuteFavorites(Favorites.Request request)
		{
			return ExecuteFavoritesAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\account\end_session
		/// </summary>
		JsonMethod<Account.EndSession.Request, Account.EndSession.Response> _executeAccountEndSessionMethod;
		
		/// <summary>
		/// This is a async execution of \account\end_session rest call. 
		/// It returns JsonResponse&lt;Account.EndSession.Response&gt;
		/// Here comes request Comments:
		///<para>      清除已验证用户的session，退出登录，并将cookie设为null。主要用于widget等web应用场合。 </para>
		///<para>                                                                                       </para>
		///<para>URL                                                                                    </para>
		///<para>	http://api.t.sina.com.cn/account/end_session.(json|xml)                              </para>
		///<para>                                                                                       </para>
		///<para>HTTP请求方式                                                                           </para>
		///<para>	POST                                                                                 </para>
		///<para>                                                                                       </para>
		///<para>是否需要登录                                                                            </para>
		///<para>	true                                                                                 </para>
		///<para>关于授权机制，参见授权机制声明                                                           </para>
		///<para>                                                                                       </para>
		///<para>请求数限制                                                                              </para>
		///<para>	true                                                                                 </para>
		///<para>关于请求数限制，参见接口访问权限说明                                                     </para>
		///<para>
		///      
		/// </summary>
		public async Task<JsonResponse<Account.EndSession.Response>> ExecuteAccountEndSessionAsync (
			Account.EndSession.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeAccountEndSessionMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \account\end_session rest call. 
		/// It returns JsonResponse&lt;Account.EndSession.Response&gt;
		/// Here comes request Comments:
		///<para>      清除已验证用户的session，退出登录，并将cookie设为null。主要用于widget等web应用场合。 </para>
		///<para>                                                                                       </para>
		///<para>URL                                                                                    </para>
		///<para>	http://api.t.sina.com.cn/account/end_session.(json|xml)                              </para>
		///<para>                                                                                       </para>
		///<para>HTTP请求方式                                                                           </para>
		///<para>	POST                                                                                 </para>
		///<para>                                                                                       </para>
		///<para>是否需要登录                                                                            </para>
		///<para>	true                                                                                 </para>
		///<para>关于授权机制，参见授权机制声明                                                           </para>
		///<para>                                                                                       </para>
		///<para>请求数限制                                                                              </para>
		///<para>	true                                                                                 </para>
		///<para>关于请求数限制，参见接口访问权限说明                                                     </para>
		///<para>
		///      
		/// </summary>
		public JsonResponse<Account.EndSession.Response> ExecuteAccountEndSession(Account.EndSession.Request request)
		{
			return ExecuteAccountEndSessionAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\account\get_privacy
		/// </summary>
		JsonMethod<Account.GetPrivacy.Request, Account.GetPrivacy.Response> _executeAccountGetPrivacyMethod;
		
		/// <summary>
		/// This is a async execution of \account\get_privacy rest call. 
		/// It returns JsonResponse&lt;Account.GetPrivacy.Response&gt;
		/// Here comes request Comments:
		///<para>获取隐私信息设置情况 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/account/get_privacy.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Account.GetPrivacy.Response>> ExecuteAccountGetPrivacyAsync (
			Account.GetPrivacy.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeAccountGetPrivacyMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \account\get_privacy rest call. 
		/// It returns JsonResponse&lt;Account.GetPrivacy.Response&gt;
		/// Here comes request Comments:
		///<para>获取隐私信息设置情况 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/account/get_privacy.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Account.GetPrivacy.Response> ExecuteAccountGetPrivacy(Account.GetPrivacy.Request request)
		{
			return ExecuteAccountGetPrivacyAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\account\rate_limit_status
		/// </summary>
		JsonMethod<Account.RateLimitStatus.Request, Account.RateLimitStatus.Response> _executeAccountRateLimitStatusMethod;
		
		/// <summary>
		/// This is a async execution of \account\rate_limit_status rest call. 
		/// It returns JsonResponse&lt;Account.RateLimitStatus.Response&gt;
		/// Here comes request Comments:
		///<para>获取API的访问频率限制。返回当前小时内还能访问的次数。频率限制是根据用户请求来做的限制，具体细节参见：接口访问权限说明。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/account/rate_limit_status.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Account.RateLimitStatus.Response>> ExecuteAccountRateLimitStatusAsync (
			Account.RateLimitStatus.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeAccountRateLimitStatusMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \account\rate_limit_status rest call. 
		/// It returns JsonResponse&lt;Account.RateLimitStatus.Response&gt;
		/// Here comes request Comments:
		///<para>获取API的访问频率限制。返回当前小时内还能访问的次数。频率限制是根据用户请求来做的限制，具体细节参见：接口访问权限说明。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/account/rate_limit_status.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Account.RateLimitStatus.Response> ExecuteAccountRateLimitStatus(Account.RateLimitStatus.Request request)
		{
			return ExecuteAccountRateLimitStatusAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\account\update_profile
		/// </summary>
		JsonMethod<Account.UpdateProfile.Request, Account.UpdateProfile.Response> _executeAccountUpdateProfileMethod;
		
		/// <summary>
		/// This is a async execution of \account\update_profile rest call. 
		/// It returns JsonResponse&lt;Account.UpdateProfile.Response&gt;
		/// Here comes request Comments:
		///<para>更新当前登录用户在新浪微博上的基本信息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/account/update_profile.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Account.UpdateProfile.Response>> ExecuteAccountUpdateProfileAsync (
			Account.UpdateProfile.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeAccountUpdateProfileMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \account\update_profile rest call. 
		/// It returns JsonResponse&lt;Account.UpdateProfile.Response&gt;
		/// Here comes request Comments:
		///<para>更新当前登录用户在新浪微博上的基本信息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/account/update_profile.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Account.UpdateProfile.Response> ExecuteAccountUpdateProfile(Account.UpdateProfile.Request request)
		{
			return ExecuteAccountUpdateProfileAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\account\update_profile_image
		/// </summary>
		JsonMethod<Account.UpdateProfileImage.Request, Account.UpdateProfileImage.Response> _executeAccountUpdateProfileImageMethod;
		
		/// <summary>
		/// This is a async execution of \account\update_profile_image rest call. 
		/// It returns JsonResponse&lt;Account.UpdateProfileImage.Response&gt;
		/// Here comes request Comments:
		///<para>更新用户头像。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/account/update_profile_image.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para>注意事项:</para>
		///<para>	采用multipart/form-data编码方式提交，可以参考： Form-based File Upload in HTML</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Account.UpdateProfileImage.Response>> ExecuteAccountUpdateProfileImageAsync (
			Account.UpdateProfileImage.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeAccountUpdateProfileImageMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \account\update_profile_image rest call. 
		/// It returns JsonResponse&lt;Account.UpdateProfileImage.Response&gt;
		/// Here comes request Comments:
		///<para>更新用户头像。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/account/update_profile_image.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para>注意事项:</para>
		///<para>	采用multipart/form-data编码方式提交，可以参考： Form-based File Upload in HTML</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Account.UpdateProfileImage.Response> ExecuteAccountUpdateProfileImage(Account.UpdateProfileImage.Request request)
		{
			return ExecuteAccountUpdateProfileImageAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\account\verify_credentials
		/// </summary>
		JsonMethod<Account.VerifyCredentials.Request, Account.VerifyCredentials.Response> _executeAccountVerifyCredentialsMethod;
		
		/// <summary>
		/// This is a async execution of \account\verify_credentials rest call. 
		/// It returns JsonResponse&lt;Account.VerifyCredentials.Response&gt;
		/// Here comes request Comments:
		///<para>验证用户是否已经开通微博服务。 </para>
		///<para>如果用户的新浪通行证身份验证成功，且用户已经开通微博则返回 http状态为 200，否则返回403错误。 </para>
		///<para>该接口除source以外，无其他参数。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/account/verify_credentials.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para>注意事项:</para>
		///<para>	若用户的新浪通行证身份验证成功，但未开通微博服务，则提示：40313:Error: invalid weibo user!。   若用户的新浪通行证身份验证失败，则提示：40302:Error: auth faild!</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Account.VerifyCredentials.Response>> ExecuteAccountVerifyCredentialsAsync (
			Account.VerifyCredentials.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeAccountVerifyCredentialsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \account\verify_credentials rest call. 
		/// It returns JsonResponse&lt;Account.VerifyCredentials.Response&gt;
		/// Here comes request Comments:
		///<para>验证用户是否已经开通微博服务。 </para>
		///<para>如果用户的新浪通行证身份验证成功，且用户已经开通微博则返回 http状态为 200，否则返回403错误。 </para>
		///<para>该接口除source以外，无其他参数。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/account/verify_credentials.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para>注意事项:</para>
		///<para>	若用户的新浪通行证身份验证成功，但未开通微博服务，则提示：40313:Error: invalid weibo user!。   若用户的新浪通行证身份验证失败，则提示：40302:Error: auth faild!</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Account.VerifyCredentials.Response> ExecuteAccountVerifyCredentials(Account.VerifyCredentials.Request request)
		{
			return ExecuteAccountVerifyCredentialsAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\blocks\blocking
		/// </summary>
		JsonMethod<Blocks.Blocking.Request, Blocks.Blocking.Response> _executeBlocksBlockingMethod;
		
		/// <summary>
		/// This is a async execution of \blocks\blocking rest call. 
		/// It returns JsonResponse&lt;Blocks.Blocking.Response&gt;
		/// Here comes request Comments:
		///<para>分页输出当前登录用户的黑名单列表，包括黑名单内的用户详细信息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/blocks/blocking.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Blocks.Blocking.Response>> ExecuteBlocksBlockingAsync (
			Blocks.Blocking.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeBlocksBlockingMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \blocks\blocking rest call. 
		/// It returns JsonResponse&lt;Blocks.Blocking.Response&gt;
		/// Here comes request Comments:
		///<para>分页输出当前登录用户的黑名单列表，包括黑名单内的用户详细信息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/blocks/blocking.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Blocks.Blocking.Response> ExecuteBlocksBlocking(Blocks.Blocking.Request request)
		{
			return ExecuteBlocksBlockingAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\blocks\create
		/// </summary>
		JsonMethod<Blocks.Create.Request, Blocks.Create.Response> _executeBlocksCreateMethod;
		
		/// <summary>
		/// This is a async execution of \blocks\create rest call. 
		/// It returns JsonResponse&lt;Blocks.Create.Response&gt;
		/// Here comes request Comments:
		///<para>将某用户加入登录用户的黑名单 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/blocks/create.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Blocks.Create.Response>> ExecuteBlocksCreateAsync (
			Blocks.Create.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeBlocksCreateMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \blocks\create rest call. 
		/// It returns JsonResponse&lt;Blocks.Create.Response&gt;
		/// Here comes request Comments:
		///<para>将某用户加入登录用户的黑名单 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/blocks/create.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Blocks.Create.Response> ExecuteBlocksCreate(Blocks.Create.Request request)
		{
			return ExecuteBlocksCreateAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\blocks\destroy
		/// </summary>
		JsonMethod<Blocks.Destroy.Request, Blocks.Destroy.Response> _executeBlocksDestroyMethod;
		
		/// <summary>
		/// This is a async execution of \blocks\destroy rest call. 
		/// It returns JsonResponse&lt;Blocks.Destroy.Response&gt;
		/// Here comes request Comments:
		///<para>将某用户从当前登录用户的黑名单中移除 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/blocks/destroy.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Blocks.Destroy.Response>> ExecuteBlocksDestroyAsync (
			Blocks.Destroy.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeBlocksDestroyMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \blocks\destroy rest call. 
		/// It returns JsonResponse&lt;Blocks.Destroy.Response&gt;
		/// Here comes request Comments:
		///<para>将某用户从当前登录用户的黑名单中移除 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/blocks/destroy.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Blocks.Destroy.Response> ExecuteBlocksDestroy(Blocks.Destroy.Request request)
		{
			return ExecuteBlocksDestroyAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\blocks\exists
		/// </summary>
		JsonMethod<Blocks.Exists.Request, Blocks.Exists.Response> _executeBlocksExistsMethod;
		
		/// <summary>
		/// This is a async execution of \blocks\exists rest call. 
		/// It returns JsonResponse&lt;Blocks.Exists.Response&gt;
		/// Here comes request Comments:
		///<para>检测指定用户是否在登录用户的黑名单内。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/blocks/exists.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Blocks.Exists.Response>> ExecuteBlocksExistsAsync (
			Blocks.Exists.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeBlocksExistsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \blocks\exists rest call. 
		/// It returns JsonResponse&lt;Blocks.Exists.Response&gt;
		/// Here comes request Comments:
		///<para>检测指定用户是否在登录用户的黑名单内。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/blocks/exists.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Blocks.Exists.Response> ExecuteBlocksExists(Blocks.Exists.Request request)
		{
			return ExecuteBlocksExistsAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\favorites\create
		/// </summary>
		JsonMethod<Favorites.Create.Request, Favorites.Create.Response> _executeFavoritesCreateMethod;
		
		/// <summary>
		/// This is a async execution of \favorites\create rest call. 
		/// It returns JsonResponse&lt;Favorites.Create.Response&gt;
		/// Here comes request Comments:
		///<para>收藏一条微博消息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/favorites/create.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Favorites.Create.Response>> ExecuteFavoritesCreateAsync (
			Favorites.Create.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeFavoritesCreateMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \favorites\create rest call. 
		/// It returns JsonResponse&lt;Favorites.Create.Response&gt;
		/// Here comes request Comments:
		///<para>收藏一条微博消息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/favorites/create.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Favorites.Create.Response> ExecuteFavoritesCreate(Favorites.Create.Request request)
		{
			return ExecuteFavoritesCreateAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\favorites\destroy
		/// </summary>
		JsonMethod<Favorites.Destroy.Request, Favorites.Destroy.Response> _executeFavoritesDestroyMethod;
		
		/// <summary>
		/// This is a async execution of \favorites\destroy rest call. 
		/// It returns JsonResponse&lt;Favorites.Destroy.Response&gt;
		/// Here comes request Comments:
		///<para>删除微博收藏。注意：只能删除自己收藏的信息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/favorites/destroy/:id.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Favorites.Destroy.Response>> ExecuteFavoritesDestroyAsync (
			Favorites.Destroy.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeFavoritesDestroyMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \favorites\destroy rest call. 
		/// It returns JsonResponse&lt;Favorites.Destroy.Response&gt;
		/// Here comes request Comments:
		///<para>删除微博收藏。注意：只能删除自己收藏的信息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/favorites/destroy/:id.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Favorites.Destroy.Response> ExecuteFavoritesDestroy(Favorites.Destroy.Request request)
		{
			return ExecuteFavoritesDestroyAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\favorites\destroy_batch
		/// </summary>
		JsonMethod<Favorites.DestroyBatch.Request, Favorites.DestroyBatch.Response> _executeFavoritesDestroyBatchMethod;
		
		/// <summary>
		/// This is a async execution of \favorites\destroy_batch rest call. 
		/// It returns JsonResponse&lt;Favorites.DestroyBatch.Response&gt;
		/// Here comes request Comments:
		///<para>删除微博收藏。注意：只能删除自己收藏的信息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/favorites/destroy_batch.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Favorites.DestroyBatch.Response>> ExecuteFavoritesDestroyBatchAsync (
			Favorites.DestroyBatch.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeFavoritesDestroyBatchMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \favorites\destroy_batch rest call. 
		/// It returns JsonResponse&lt;Favorites.DestroyBatch.Response&gt;
		/// Here comes request Comments:
		///<para>删除微博收藏。注意：只能删除自己收藏的信息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/favorites/destroy_batch.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Favorites.DestroyBatch.Response> ExecuteFavoritesDestroyBatch(Favorites.DestroyBatch.Request request)
		{
			return ExecuteFavoritesDestroyBatchAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\friendships\create
		/// </summary>
		JsonMethod<Friendships.Create.Request, Friendships.Create.Response> _executeFriendshipsCreateMethod;
		
		/// <summary>
		/// This is a async execution of \friendships\create rest call. 
		/// It returns JsonResponse&lt;Friendships.Create.Response&gt;
		/// Here comes request Comments:
		///<para>关注一个用户。关注成功则返回关注人的资料，目前的最多关注2000人。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/friendships/create.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Friendships.Create.Response>> ExecuteFriendshipsCreateAsync (
			Friendships.Create.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeFriendshipsCreateMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \friendships\create rest call. 
		/// It returns JsonResponse&lt;Friendships.Create.Response&gt;
		/// Here comes request Comments:
		///<para>关注一个用户。关注成功则返回关注人的资料，目前的最多关注2000人。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/friendships/create.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Friendships.Create.Response> ExecuteFriendshipsCreate(Friendships.Create.Request request)
		{
			return ExecuteFriendshipsCreateAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\friendships\destroy
		/// </summary>
		JsonMethod<Friendships.Destroy.Request, Friendships.Destroy.Response> _executeFriendshipsDestroyMethod;
		
		/// <summary>
		/// This is a async execution of \friendships\destroy rest call. 
		/// It returns JsonResponse&lt;Friendships.Destroy.Response&gt;
		/// Here comes request Comments:
		///<para>取消对某用户的关注。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/friendships/destroy.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Friendships.Destroy.Response>> ExecuteFriendshipsDestroyAsync (
			Friendships.Destroy.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeFriendshipsDestroyMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \friendships\destroy rest call. 
		/// It returns JsonResponse&lt;Friendships.Destroy.Response&gt;
		/// Here comes request Comments:
		///<para>取消对某用户的关注。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/friendships/destroy.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Friendships.Destroy.Response> ExecuteFriendshipsDestroy(Friendships.Destroy.Request request)
		{
			return ExecuteFriendshipsDestroyAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\friendships\exists
		/// </summary>
		JsonMethod<Friendships.Exists.Request, Friendships.Exists.Response> _executeFriendshipsExistsMethod;
		
		/// <summary>
		/// This is a async execution of \friendships\exists rest call. 
		/// It returns JsonResponse&lt;Friendships.Exists.Response&gt;
		/// Here comes request Comments:
		///<para>查看用户A是否关注了用户B。如果用户A关注了用户B，则返回true，否则返回false。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/friendships/exists.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Friendships.Exists.Response>> ExecuteFriendshipsExistsAsync (
			Friendships.Exists.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeFriendshipsExistsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \friendships\exists rest call. 
		/// It returns JsonResponse&lt;Friendships.Exists.Response&gt;
		/// Here comes request Comments:
		///<para>查看用户A是否关注了用户B。如果用户A关注了用户B，则返回true，否则返回false。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/friendships/exists.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Friendships.Exists.Response> ExecuteFriendshipsExists(Friendships.Exists.Request request)
		{
			return ExecuteFriendshipsExistsAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\friendships\show
		/// </summary>
		JsonMethod<Friendships.Show.Request, Friendships.Show.Response> _executeFriendshipsShowMethod;
		
		/// <summary>
		/// This is a async execution of \friendships\show rest call. 
		/// It returns JsonResponse&lt;Friendships.Show.Response&gt;
		/// Here comes request Comments:
		///<para>返回两个用户关注关系的详细情况 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/friendships/show.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Friendships.Show.Response>> ExecuteFriendshipsShowAsync (
			Friendships.Show.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeFriendshipsShowMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \friendships\show rest call. 
		/// It returns JsonResponse&lt;Friendships.Show.Response&gt;
		/// Here comes request Comments:
		///<para>返回两个用户关注关系的详细情况 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/friendships/show.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Friendships.Show.Response> ExecuteFriendshipsShow(Friendships.Show.Request request)
		{
			return ExecuteFriendshipsShowAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\short_url\expand
		/// </summary>
		JsonMethod<ShortUrl.Expand.Request, ShortUrl.Expand.Response> _executeShortUrlExpandMethod;
		
		/// <summary>
		/// This is a async execution of \short_url\expand rest call. 
		/// It returns JsonResponse&lt;ShortUrl.Expand.Response&gt;
		/// Here comes request Comments:
		///<para>将一个或多个短链接还原成原始的长链接 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/short_url/expand.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	false  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<ShortUrl.Expand.Response>> ExecuteShortUrlExpandAsync (
			ShortUrl.Expand.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeShortUrlExpandMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \short_url\expand rest call. 
		/// It returns JsonResponse&lt;ShortUrl.Expand.Response&gt;
		/// Here comes request Comments:
		///<para>将一个或多个短链接还原成原始的长链接 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/short_url/expand.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	false  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<ShortUrl.Expand.Response> ExecuteShortUrlExpand(ShortUrl.Expand.Request request)
		{
			return ExecuteShortUrlExpandAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\short_url\shorten
		/// </summary>
		JsonMethod<ShortUrl.Shorten.Request, ShortUrl.Shorten.Response> _executeShortUrlShortenMethod;
		
		/// <summary>
		/// This is a async execution of \short_url\shorten rest call. 
		/// It returns JsonResponse&lt;ShortUrl.Shorten.Response&gt;
		/// Here comes request Comments:
		///<para>将一个或多个长链接转换成短链接 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/short_url/shorten.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	false  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<ShortUrl.Shorten.Response>> ExecuteShortUrlShortenAsync (
			ShortUrl.Shorten.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeShortUrlShortenMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \short_url\shorten rest call. 
		/// It returns JsonResponse&lt;ShortUrl.Shorten.Response&gt;
		/// Here comes request Comments:
		///<para>将一个或多个长链接转换成短链接 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/short_url/shorten.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	false  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<ShortUrl.Shorten.Response> ExecuteShortUrlShorten(ShortUrl.Shorten.Request request)
		{
			return ExecuteShortUrlShortenAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\short_url\comment\comments
		/// </summary>
		JsonMethod<ShortUrl.Comment.Comments.Request, ShortUrl.Comment.Comments.Response> _executeShortUrlCommentCommentsMethod;
		
		/// <summary>
		/// This is a async execution of \short_url\comment\comments rest call. 
		/// It returns JsonResponse&lt;ShortUrl.Comment.Comments.Response&gt;
		/// Here comes request Comments:
		///<para>取得包含指定单个短链接的最新微博评论内容 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/short_url/comment/comments.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<ShortUrl.Comment.Comments.Response>> ExecuteShortUrlCommentCommentsAsync (
			ShortUrl.Comment.Comments.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeShortUrlCommentCommentsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \short_url\comment\comments rest call. 
		/// It returns JsonResponse&lt;ShortUrl.Comment.Comments.Response&gt;
		/// Here comes request Comments:
		///<para>取得包含指定单个短链接的最新微博评论内容 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/short_url/comment/comments.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<ShortUrl.Comment.Comments.Response> ExecuteShortUrlCommentComments(ShortUrl.Comment.Comments.Request request)
		{
			return ExecuteShortUrlCommentCommentsAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\short_url\comment\counts
		/// </summary>
		JsonMethod<ShortUrl.Comment.Counts.Request, ShortUrl.Comment.Counts.Response> _executeShortUrlCommentCountsMethod;
		
		/// <summary>
		/// This is a async execution of \short_url\comment\counts rest call. 
		/// It returns JsonResponse&lt;ShortUrl.Comment.Counts.Response&gt;
		/// Here comes request Comments:
		///<para>取得一个短链接在微博上的微博评论数 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/short_url/comment/counts.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	false  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<ShortUrl.Comment.Counts.Response>> ExecuteShortUrlCommentCountsAsync (
			ShortUrl.Comment.Counts.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeShortUrlCommentCountsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \short_url\comment\counts rest call. 
		/// It returns JsonResponse&lt;ShortUrl.Comment.Counts.Response&gt;
		/// Here comes request Comments:
		///<para>取得一个短链接在微博上的微博评论数 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/short_url/comment/counts.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	false  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<ShortUrl.Comment.Counts.Response> ExecuteShortUrlCommentCounts(ShortUrl.Comment.Counts.Request request)
		{
			return ExecuteShortUrlCommentCountsAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\short_url\share\counts
		/// </summary>
		JsonMethod<ShortUrl.Share.Counts.Request, ShortUrl.Share.Counts.Response> _executeShortUrlShareCountsMethod;
		
		/// <summary>
		/// This is a async execution of \short_url\share\counts rest call. 
		/// It returns JsonResponse&lt;ShortUrl.Share.Counts.Response&gt;
		/// Here comes request Comments:
		///<para>取得一个短链接在微博上的微博分享数（包含原创和转发的微博） </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/short_url/share/counts.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	false  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<ShortUrl.Share.Counts.Response>> ExecuteShortUrlShareCountsAsync (
			ShortUrl.Share.Counts.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeShortUrlShareCountsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \short_url\share\counts rest call. 
		/// It returns JsonResponse&lt;ShortUrl.Share.Counts.Response&gt;
		/// Here comes request Comments:
		///<para>取得一个短链接在微博上的微博分享数（包含原创和转发的微博） </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/short_url/share/counts.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	false  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<ShortUrl.Share.Counts.Response> ExecuteShortUrlShareCounts(ShortUrl.Share.Counts.Request request)
		{
			return ExecuteShortUrlShareCountsAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\short_url\share\statuses
		/// </summary>
		JsonMethod<ShortUrl.Share.Statuses.Request, ShortUrl.Share.Statuses.Response> _executeShortUrlShareStatusesMethod;
		
		/// <summary>
		/// This is a async execution of \short_url\share\statuses rest call. 
		/// It returns JsonResponse&lt;ShortUrl.Share.Statuses.Response&gt;
		/// Here comes request Comments:
		///<para>取得包含指定单个短链接的最新微博内容 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/short_url/share/statuses.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<ShortUrl.Share.Statuses.Response>> ExecuteShortUrlShareStatusesAsync (
			ShortUrl.Share.Statuses.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeShortUrlShareStatusesMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \short_url\share\statuses rest call. 
		/// It returns JsonResponse&lt;ShortUrl.Share.Statuses.Response&gt;
		/// Here comes request Comments:
		///<para>取得包含指定单个短链接的最新微博内容 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/short_url/share/statuses.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<ShortUrl.Share.Statuses.Response> ExecuteShortUrlShareStatuses(ShortUrl.Share.Statuses.Request request)
		{
			return ExecuteShortUrlShareStatusesAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\statuses\comment
		/// </summary>
		JsonMethod<Statuses.Comment.Request, Statuses.Comment.Response> _executeStatusesCommentMethod;
		
		/// <summary>
		/// This is a async execution of \statuses\comment rest call. 
		/// It returns JsonResponse&lt;Statuses.Comment.Response&gt;
		/// Here comes request Comments:
		///<para>对一条微博信息进行评论。请求必须用POST方式提交。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/comment.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Statuses.Comment.Response>> ExecuteStatusesCommentAsync (
			Statuses.Comment.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeStatusesCommentMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \statuses\comment rest call. 
		/// It returns JsonResponse&lt;Statuses.Comment.Response&gt;
		/// Here comes request Comments:
		///<para>对一条微博信息进行评论。请求必须用POST方式提交。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/comment.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Statuses.Comment.Response> ExecuteStatusesComment(Statuses.Comment.Request request)
		{
			return ExecuteStatusesCommentAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\statuses\comments_by_me
		/// </summary>
		JsonMethod<Statuses.CommentsByMe.Request, Statuses.CommentsByMe.Response> _executeStatusesCommentsByMeMethod;
		
		/// <summary>
		/// This is a async execution of \statuses\comments_by_me rest call. 
		/// It returns JsonResponse&lt;Statuses.CommentsByMe.Response&gt;
		/// Here comes request Comments:
		///<para>获取当前用户发出的评论 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/comments_by_me.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Statuses.CommentsByMe.Response>> ExecuteStatusesCommentsByMeAsync (
			Statuses.CommentsByMe.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeStatusesCommentsByMeMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \statuses\comments_by_me rest call. 
		/// It returns JsonResponse&lt;Statuses.CommentsByMe.Response&gt;
		/// Here comes request Comments:
		///<para>获取当前用户发出的评论 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/comments_by_me.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Statuses.CommentsByMe.Response> ExecuteStatusesCommentsByMe(Statuses.CommentsByMe.Request request)
		{
			return ExecuteStatusesCommentsByMeAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\statuses\comments_timeline
		/// </summary>
		JsonMethod<Statuses.CommentsTimeline.Request, Statuses.CommentsTimeline.Response> _executeStatusesCommentsTimelineMethod;
		
		/// <summary>
		/// This is a async execution of \statuses\comments_timeline rest call. 
		/// It returns JsonResponse&lt;Statuses.CommentsTimeline.Response&gt;
		/// Here comes request Comments:
		///<para>返回最新n条发送及收到的评论。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/comments_timeline.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Statuses.CommentsTimeline.Response>> ExecuteStatusesCommentsTimelineAsync (
			Statuses.CommentsTimeline.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeStatusesCommentsTimelineMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \statuses\comments_timeline rest call. 
		/// It returns JsonResponse&lt;Statuses.CommentsTimeline.Response&gt;
		/// Here comes request Comments:
		///<para>返回最新n条发送及收到的评论。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/comments_timeline.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Statuses.CommentsTimeline.Response> ExecuteStatusesCommentsTimeline(Statuses.CommentsTimeline.Request request)
		{
			return ExecuteStatusesCommentsTimelineAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\statuses\comments_to_me
		/// </summary>
		JsonMethod<Statuses.CommentsToMe.Request, Statuses.CommentsToMe.Response> _executeStatusesCommentsToMeMethod;
		
		/// <summary>
		/// This is a async execution of \statuses\comments_to_me rest call. 
		/// It returns JsonResponse&lt;Statuses.CommentsToMe.Response&gt;
		/// Here comes request Comments:
		///<para>返回当前登录用户收到的评论 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/comments_to_me.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Statuses.CommentsToMe.Response>> ExecuteStatusesCommentsToMeAsync (
			Statuses.CommentsToMe.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeStatusesCommentsToMeMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \statuses\comments_to_me rest call. 
		/// It returns JsonResponse&lt;Statuses.CommentsToMe.Response&gt;
		/// Here comes request Comments:
		///<para>返回当前登录用户收到的评论 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/comments_to_me.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Statuses.CommentsToMe.Response> ExecuteStatusesCommentsToMe(Statuses.CommentsToMe.Request request)
		{
			return ExecuteStatusesCommentsToMeAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\statuses\comment_destroy
		/// </summary>
		JsonMethod<Statuses.CommentDestroy.Request, Statuses.CommentDestroy.Response> _executeStatusesCommentDestroyMethod;
		
		/// <summary>
		/// This is a async execution of \statuses\comment_destroy rest call. 
		/// It returns JsonResponse&lt;Statuses.CommentDestroy.Response&gt;
		/// Here comes request Comments:
		///<para>删除评论。注意：只能删除登录用户自己发布的评论，不可以删除其他人的评论。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/comment_destroy/:id.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Statuses.CommentDestroy.Response>> ExecuteStatusesCommentDestroyAsync (
			Statuses.CommentDestroy.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeStatusesCommentDestroyMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \statuses\comment_destroy rest call. 
		/// It returns JsonResponse&lt;Statuses.CommentDestroy.Response&gt;
		/// Here comes request Comments:
		///<para>删除评论。注意：只能删除登录用户自己发布的评论，不可以删除其他人的评论。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/comment_destroy/:id.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Statuses.CommentDestroy.Response> ExecuteStatusesCommentDestroy(Statuses.CommentDestroy.Request request)
		{
			return ExecuteStatusesCommentDestroyAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\statuses\comment_destroy_batch
		/// </summary>
		JsonMethod<Statuses.CommentDestroyBatch.Request, Statuses.CommentDestroyBatch.Response> _executeStatusesCommentDestroyBatchMethod;
		
		/// <summary>
		/// This is a async execution of \statuses\comment_destroy_batch rest call. 
		/// It returns JsonResponse&lt;Statuses.CommentDestroyBatch.Response&gt;
		/// Here comes request Comments:
		///<para>批量删除评论。注意：只能删除登录用户自己发布的评论，不可以删除其他人的评论。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/comment/destroy_batch.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Statuses.CommentDestroyBatch.Response>> ExecuteStatusesCommentDestroyBatchAsync (
			Statuses.CommentDestroyBatch.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeStatusesCommentDestroyBatchMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \statuses\comment_destroy_batch rest call. 
		/// It returns JsonResponse&lt;Statuses.CommentDestroyBatch.Response&gt;
		/// Here comes request Comments:
		///<para>批量删除评论。注意：只能删除登录用户自己发布的评论，不可以删除其他人的评论。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/comment/destroy_batch.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Statuses.CommentDestroyBatch.Response> ExecuteStatusesCommentDestroyBatch(Statuses.CommentDestroyBatch.Request request)
		{
			return ExecuteStatusesCommentDestroyBatchAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\statuses\counts
		/// </summary>
		JsonMethod<Statuses.Counts.Request, Statuses.Counts.Response> _executeStatusesCountsMethod;
		
		/// <summary>
		/// This is a async execution of \statuses\counts rest call. 
		/// It returns JsonResponse&lt;Statuses.Counts.Response&gt;
		/// Here comes request Comments:
		///<para>批量获取n条微博消息的评论数和转发数。一次请求最多可以获取20条微博消息的评论数和转发数 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/counts.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Statuses.Counts.Response>> ExecuteStatusesCountsAsync (
			Statuses.Counts.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeStatusesCountsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \statuses\counts rest call. 
		/// It returns JsonResponse&lt;Statuses.Counts.Response&gt;
		/// Here comes request Comments:
		///<para>批量获取n条微博消息的评论数和转发数。一次请求最多可以获取20条微博消息的评论数和转发数 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/counts.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Statuses.Counts.Response> ExecuteStatusesCounts(Statuses.Counts.Request request)
		{
			return ExecuteStatusesCountsAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\statuses\followers
		/// </summary>
		JsonMethod<Statuses.Followers.Request, Statuses.Followers.Response> _executeStatusesFollowersMethod;
		
		/// <summary>
		/// This is a async execution of \statuses\followers rest call. 
		/// It returns JsonResponse&lt;Statuses.Followers.Response&gt;
		/// Here comes request Comments:
		///<para>获取用户粉丝列表及每个粉丝的最新一条微博，返回结果按粉丝的关注时间倒序排列，最新关注的粉丝排在最前面。每次返回20个,通过cursor参数来取得多于20的粉丝。注意目前接口最多只返回5000个粉丝。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/followers.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	false  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Statuses.Followers.Response>> ExecuteStatusesFollowersAsync (
			Statuses.Followers.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeStatusesFollowersMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \statuses\followers rest call. 
		/// It returns JsonResponse&lt;Statuses.Followers.Response&gt;
		/// Here comes request Comments:
		///<para>获取用户粉丝列表及每个粉丝的最新一条微博，返回结果按粉丝的关注时间倒序排列，最新关注的粉丝排在最前面。每次返回20个,通过cursor参数来取得多于20的粉丝。注意目前接口最多只返回5000个粉丝。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/followers.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	false  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Statuses.Followers.Response> ExecuteStatusesFollowers(Statuses.Followers.Request request)
		{
			return ExecuteStatusesFollowersAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\statuses\friends
		/// </summary>
		JsonMethod<Statuses.Friends.Request, Statuses.Friends.Response> _executeStatusesFriendsMethod;
		
		/// <summary>
		/// This is a async execution of \statuses\friends rest call. 
		/// It returns JsonResponse&lt;Statuses.Friends.Response&gt;
		/// Here comes request Comments:
		///<para>获取用户关注列表及每个关注用户的最新一条微博，返回结果按关注时间倒序排列，最新关注的用户排在最前面。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/friends.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Statuses.Friends.Response>> ExecuteStatusesFriendsAsync (
			Statuses.Friends.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeStatusesFriendsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \statuses\friends rest call. 
		/// It returns JsonResponse&lt;Statuses.Friends.Response&gt;
		/// Here comes request Comments:
		///<para>获取用户关注列表及每个关注用户的最新一条微博，返回结果按关注时间倒序排列，最新关注的用户排在最前面。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/friends.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Statuses.Friends.Response> ExecuteStatusesFriends(Statuses.Friends.Request request)
		{
			return ExecuteStatusesFriendsAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\statuses\friends_timeline
		/// </summary>
		JsonMethod<Statuses.FriendsTimeline.Request, Statuses.FriendsTimeline.Response> _executeStatusesFriendsTimelineMethod;
		
		/// <summary>
		/// This is a async execution of \statuses\friends_timeline rest call. 
		/// It returns JsonResponse&lt;Statuses.FriendsTimeline.Response&gt;
		/// Here comes request Comments:
		///<para>获取当前登录用户及其所关注用户的最新微博消息。和用户登录 http://t.sina.com.cn 后在“我的首页”中看到的内容相同。</para>
		///<para>别名statuses/home_timeline </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/friends_timeline.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Statuses.FriendsTimeline.Response>> ExecuteStatusesFriendsTimelineAsync (
			Statuses.FriendsTimeline.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeStatusesFriendsTimelineMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \statuses\friends_timeline rest call. 
		/// It returns JsonResponse&lt;Statuses.FriendsTimeline.Response&gt;
		/// Here comes request Comments:
		///<para>获取当前登录用户及其所关注用户的最新微博消息。和用户登录 http://t.sina.com.cn 后在“我的首页”中看到的内容相同。</para>
		///<para>别名statuses/home_timeline </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/friends_timeline.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Statuses.FriendsTimeline.Response> ExecuteStatusesFriendsTimeline(Statuses.FriendsTimeline.Request request)
		{
			return ExecuteStatusesFriendsTimelineAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\statuses\public_timeline
		/// </summary>
		JsonMethod<Statuses.PublicTimeline.Request, Statuses.PublicTimeline.Response> _executeStatusesPublicTimelineMethod;
		
		/// <summary>
		/// This is a async execution of \statuses\public_timeline rest call. 
		/// It returns JsonResponse&lt;Statuses.PublicTimeline.Response&gt;
		/// Here comes request Comments:
		///<para>返回最新的20条公共微博。返回结果非完全实时，最长会缓存60秒 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/public_timeline.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	false  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Statuses.PublicTimeline.Response>> ExecuteStatusesPublicTimelineAsync (
			Statuses.PublicTimeline.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeStatusesPublicTimelineMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \statuses\public_timeline rest call. 
		/// It returns JsonResponse&lt;Statuses.PublicTimeline.Response&gt;
		/// Here comes request Comments:
		///<para>返回最新的20条公共微博。返回结果非完全实时，最长会缓存60秒 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/public_timeline.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	false  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Statuses.PublicTimeline.Response> ExecuteStatusesPublicTimeline(Statuses.PublicTimeline.Request request)
		{
			return ExecuteStatusesPublicTimelineAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\statuses\reply
		/// </summary>
		JsonMethod<Statuses.Reply.Request, Statuses.Reply.Response> _executeStatusesReplyMethod;
		
		/// <summary>
		/// This is a async execution of \statuses\reply rest call. 
		/// It returns JsonResponse&lt;Statuses.Reply.Response&gt;
		/// Here comes request Comments:
		///<para>回复评论。请求必须用POST方式提交。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/reply.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Statuses.Reply.Response>> ExecuteStatusesReplyAsync (
			Statuses.Reply.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeStatusesReplyMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \statuses\reply rest call. 
		/// It returns JsonResponse&lt;Statuses.Reply.Response&gt;
		/// Here comes request Comments:
		///<para>回复评论。请求必须用POST方式提交。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/reply.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Statuses.Reply.Response> ExecuteStatusesReply(Statuses.Reply.Request request)
		{
			return ExecuteStatusesReplyAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\statuses\repost
		/// </summary>
		JsonMethod<Statuses.Repost.Request, Statuses.Repost.Response> _executeStatusesRepostMethod;
		
		/// <summary>
		/// This is a async execution of \statuses\repost rest call. 
		/// It returns JsonResponse&lt;Statuses.Repost.Response&gt;
		/// Here comes request Comments:
		///<para>转发一条微博消息。请求必须用POST方式提交。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/repost.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Statuses.Repost.Response>> ExecuteStatusesRepostAsync (
			Statuses.Repost.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeStatusesRepostMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \statuses\repost rest call. 
		/// It returns JsonResponse&lt;Statuses.Repost.Response&gt;
		/// Here comes request Comments:
		///<para>转发一条微博消息。请求必须用POST方式提交。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/repost.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Statuses.Repost.Response> ExecuteStatusesRepost(Statuses.Repost.Request request)
		{
			return ExecuteStatusesRepostAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\statuses\repost_by_me
		/// </summary>
		JsonMethod<Statuses.RepostByMe.Request, Statuses.RepostByMe.Response> _executeStatusesRepostByMeMethod;
		
		/// <summary>
		/// This is a async execution of \statuses\repost_by_me rest call. 
		/// It returns JsonResponse&lt;Statuses.RepostByMe.Response&gt;
		/// Here comes request Comments:
		///<para>获取用户最新转发的n条微博消息 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/repost_by_me.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Statuses.RepostByMe.Response>> ExecuteStatusesRepostByMeAsync (
			Statuses.RepostByMe.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeStatusesRepostByMeMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \statuses\repost_by_me rest call. 
		/// It returns JsonResponse&lt;Statuses.RepostByMe.Response&gt;
		/// Here comes request Comments:
		///<para>获取用户最新转发的n条微博消息 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/repost_by_me.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Statuses.RepostByMe.Response> ExecuteStatusesRepostByMe(Statuses.RepostByMe.Request request)
		{
			return ExecuteStatusesRepostByMeAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\statuses\reset_count
		/// </summary>
		JsonMethod<Statuses.ResetCount.Request, Statuses.ResetCount.Response> _executeStatusesResetCountMethod;
		
		/// <summary>
		/// This is a async execution of \statuses\reset_count rest call. 
		/// It returns JsonResponse&lt;Statuses.ResetCount.Response&gt;
		/// Here comes request Comments:
		///<para>将当前登录用户的某种新消息的未读数为0。可以清零的计数类别有：1. 评论数，2. @me数，3. 私信数，4. 关注数 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/reset_count.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	false  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Statuses.ResetCount.Response>> ExecuteStatusesResetCountAsync (
			Statuses.ResetCount.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeStatusesResetCountMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \statuses\reset_count rest call. 
		/// It returns JsonResponse&lt;Statuses.ResetCount.Response&gt;
		/// Here comes request Comments:
		///<para>将当前登录用户的某种新消息的未读数为0。可以清零的计数类别有：1. 评论数，2. @me数，3. 私信数，4. 关注数 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/reset_count.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	false  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Statuses.ResetCount.Response> ExecuteStatusesResetCount(Statuses.ResetCount.Request request)
		{
			return ExecuteStatusesResetCountAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\statuses\show
		/// </summary>
		JsonMethod<Statuses.Show.Request, Statuses.Show.Response> _executeStatusesShowMethod;
		
		/// <summary>
		/// This is a async execution of \statuses\show rest call. 
		/// It returns JsonResponse&lt;Statuses.Show.Response&gt;
		/// Here comes request Comments:
		///<para>根据ID获取单条微博消息，以及该微博消息的作者信息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/show/:id.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Statuses.Show.Response>> ExecuteStatusesShowAsync (
			Statuses.Show.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeStatusesShowMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \statuses\show rest call. 
		/// It returns JsonResponse&lt;Statuses.Show.Response&gt;
		/// Here comes request Comments:
		///<para>根据ID获取单条微博消息，以及该微博消息的作者信息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/show/:id.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Statuses.Show.Response> ExecuteStatusesShow(Statuses.Show.Request request)
		{
			return ExecuteStatusesShowAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\statuses\unread
		/// </summary>
		JsonMethod<Statuses.Unread.Request, Statuses.Unread.Response> _executeStatusesUnreadMethod;
		
		/// <summary>
		/// This is a async execution of \statuses\unread rest call. 
		/// It returns JsonResponse&lt;Statuses.Unread.Response&gt;
		/// Here comes request Comments:
		///<para>获取当前用户Web主站未读消息数，包括： </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/unread.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Statuses.Unread.Response>> ExecuteStatusesUnreadAsync (
			Statuses.Unread.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeStatusesUnreadMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \statuses\unread rest call. 
		/// It returns JsonResponse&lt;Statuses.Unread.Response&gt;
		/// Here comes request Comments:
		///<para>获取当前用户Web主站未读消息数，包括： </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/unread.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Statuses.Unread.Response> ExecuteStatusesUnread(Statuses.Unread.Request request)
		{
			return ExecuteStatusesUnreadAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\statuses\update
		/// </summary>
		JsonMethod<Statuses.Update.Request, Statuses.Update.Response> _executeStatusesUpdateMethod;
		
		/// <summary>
		/// This is a async execution of \statuses\update rest call. 
		/// It returns JsonResponse&lt;Statuses.Update.Response&gt;
		/// Here comes request Comments:
		///<para>发布一条微博信息。也可以同时转发某条微博。请求必须用POST方式提交。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/update.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Statuses.Update.Response>> ExecuteStatusesUpdateAsync (
			Statuses.Update.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeStatusesUpdateMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \statuses\update rest call. 
		/// It returns JsonResponse&lt;Statuses.Update.Response&gt;
		/// Here comes request Comments:
		///<para>发布一条微博信息。也可以同时转发某条微博。请求必须用POST方式提交。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/update.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Statuses.Update.Response> ExecuteStatusesUpdate(Statuses.Update.Request request)
		{
			return ExecuteStatusesUpdateAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\statuses\upload
		/// </summary>
		JsonMethod<Statuses.Upload.Request, Statuses.Upload.Response> _executeStatusesUploadMethod;
		
		/// <summary>
		/// This is a async execution of \statuses\upload rest call. 
		/// It returns JsonResponse&lt;Statuses.Upload.Response&gt;
		/// Here comes request Comments:
		///<para>发表带图片的微博。必须用POST方式提交pic参数，且Content-Type必须设置为multipart/form-data。图片大小<5M。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/upload.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Statuses.Upload.Response>> ExecuteStatusesUploadAsync (
			Statuses.Upload.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeStatusesUploadMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \statuses\upload rest call. 
		/// It returns JsonResponse&lt;Statuses.Upload.Response&gt;
		/// Here comes request Comments:
		///<para>发表带图片的微博。必须用POST方式提交pic参数，且Content-Type必须设置为multipart/form-data。图片大小<5M。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/upload.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Statuses.Upload.Response> ExecuteStatusesUpload(Statuses.Upload.Request request)
		{
			return ExecuteStatusesUploadAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\statuses\user_timeline
		/// </summary>
		JsonMethod<Statuses.UserTimeline.Request, Statuses.UserTimeline.Response> _executeStatusesUserTimelineMethod;
		
		/// <summary>
		/// This is a async execution of \statuses\user_timeline rest call. 
		/// It returns JsonResponse&lt;Statuses.UserTimeline.Response&gt;
		/// Here comes request Comments:
		///<para>返回用户最新发表的微博消息列表。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/user_timeline.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Statuses.UserTimeline.Response>> ExecuteStatusesUserTimelineAsync (
			Statuses.UserTimeline.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeStatusesUserTimelineMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \statuses\user_timeline rest call. 
		/// It returns JsonResponse&lt;Statuses.UserTimeline.Response&gt;
		/// Here comes request Comments:
		///<para>返回用户最新发表的微博消息列表。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/user_timeline.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Statuses.UserTimeline.Response> ExecuteStatusesUserTimeline(Statuses.UserTimeline.Request request)
		{
			return ExecuteStatusesUserTimelineAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\tags\create
		/// </summary>
		JsonMethod<Tags.Create.Request, Tags.Create.Response> _executeTagsCreateMethod;
		
		/// <summary>
		/// This is a async execution of \tags\create rest call. 
		/// It returns JsonResponse&lt;Tags.Create.Response&gt;
		/// Here comes request Comments:
		///<para>为当前登录用户添加新的用户标签 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/tags/create.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Tags.Create.Response>> ExecuteTagsCreateAsync (
			Tags.Create.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeTagsCreateMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \tags\create rest call. 
		/// It returns JsonResponse&lt;Tags.Create.Response&gt;
		/// Here comes request Comments:
		///<para>为当前登录用户添加新的用户标签 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/tags/create.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Tags.Create.Response> ExecuteTagsCreate(Tags.Create.Request request)
		{
			return ExecuteTagsCreateAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\tags\suggestions
		/// </summary>
		JsonMethod<Tags.Suggestions.Request, Tags.Suggestions.Response> _executeTagsSuggestionsMethod;
		
		/// <summary>
		/// This is a async execution of \tags\suggestions rest call. 
		/// It returns JsonResponse&lt;Tags.Suggestions.Response&gt;
		/// Here comes request Comments:
		///<para>获取当前登录用户感兴趣的推荐标签列表 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/tags/suggestions.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Tags.Suggestions.Response>> ExecuteTagsSuggestionsAsync (
			Tags.Suggestions.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeTagsSuggestionsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \tags\suggestions rest call. 
		/// It returns JsonResponse&lt;Tags.Suggestions.Response&gt;
		/// Here comes request Comments:
		///<para>获取当前登录用户感兴趣的推荐标签列表 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/tags/suggestions.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Tags.Suggestions.Response> ExecuteTagsSuggestions(Tags.Suggestions.Request request)
		{
			return ExecuteTagsSuggestionsAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\trends\follow
		/// </summary>
		JsonMethod<Trends.Follow.Request, Trends.Follow.Response> _executeTrendsFollowMethod;
		
		/// <summary>
		/// This is a async execution of \trends\follow rest call. 
		/// It returns JsonResponse&lt;Trends.Follow.Response&gt;
		/// Here comes request Comments:
		///<para>关注某话题。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/trends/follow.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Trends.Follow.Response>> ExecuteTrendsFollowAsync (
			Trends.Follow.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeTrendsFollowMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \trends\follow rest call. 
		/// It returns JsonResponse&lt;Trends.Follow.Response&gt;
		/// Here comes request Comments:
		///<para>关注某话题。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/trends/follow.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Trends.Follow.Response> ExecuteTrendsFollow(Trends.Follow.Request request)
		{
			return ExecuteTrendsFollowAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\trends\statuses
		/// </summary>
		JsonMethod<Trends.Statuses.Request, Trends.Statuses.Response> _executeTrendsStatusesMethod;
		
		/// <summary>
		/// This is a async execution of \trends\statuses rest call. 
		/// It returns JsonResponse&lt;Trends.Statuses.Response&gt;
		/// Here comes request Comments:
		///<para>获取某话题下的微博消息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/trends/statuses.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Trends.Statuses.Response>> ExecuteTrendsStatusesAsync (
			Trends.Statuses.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeTrendsStatusesMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \trends\statuses rest call. 
		/// It returns JsonResponse&lt;Trends.Statuses.Response&gt;
		/// Here comes request Comments:
		///<para>获取某话题下的微博消息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/trends/statuses.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Trends.Statuses.Response> ExecuteTrendsStatuses(Trends.Statuses.Request request)
		{
			return ExecuteTrendsStatusesAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\trends\trends
		/// </summary>
		JsonMethod<Trends.Trends.Request, Trends.Trends.Response> _executeTrendsTrendsMethod;
		
		/// <summary>
		/// This is a async execution of \trends\trends rest call. 
		/// It returns JsonResponse&lt;Trends.Trends.Response&gt;
		/// Here comes request Comments:
		///<para>获取某用户的话题。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/trends.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Trends.Trends.Response>> ExecuteTrendsTrendsAsync (
			Trends.Trends.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeTrendsTrendsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \trends\trends rest call. 
		/// It returns JsonResponse&lt;Trends.Trends.Response&gt;
		/// Here comes request Comments:
		///<para>获取某用户的话题。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/trends.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Trends.Trends.Response> ExecuteTrendsTrends(Trends.Trends.Request request)
		{
			return ExecuteTrendsTrendsAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\user\friends\update_remark
		/// </summary>
		JsonMethod<User.Friends.UpdateRemark.Request, User.Friends.UpdateRemark.Response> _executeUserFriendsUpdateRemarkMethod;
		
		/// <summary>
		/// This is a async execution of \user\friends\update_remark rest call. 
		/// It returns JsonResponse&lt;User.Friends.UpdateRemark.Response&gt;
		/// Here comes request Comments:
		///<para>更新当前登录用户所关注的某个好友的备注信息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/user/friends/update_remark.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<User.Friends.UpdateRemark.Response>> ExecuteUserFriendsUpdateRemarkAsync (
			User.Friends.UpdateRemark.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeUserFriendsUpdateRemarkMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \user\friends\update_remark rest call. 
		/// It returns JsonResponse&lt;User.Friends.UpdateRemark.Response&gt;
		/// Here comes request Comments:
		///<para>更新当前登录用户所关注的某个好友的备注信息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/user/friends/update_remark.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<User.Friends.UpdateRemark.Response> ExecuteUserFriendsUpdateRemark(User.Friends.UpdateRemark.Request request)
		{
			return ExecuteUserFriendsUpdateRemarkAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\users\hot
		/// </summary>
		JsonMethod<Users.Hot.Request, Users.Hot.Response> _executeUsersHotMethod;
		
		/// <summary>
		/// This is a async execution of \users\hot rest call. 
		/// It returns JsonResponse&lt;Users.Hot.Response&gt;
		/// Here comes request Comments:
		///<para>返回系统推荐的用户列表。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/users/hot.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Users.Hot.Response>> ExecuteUsersHotAsync (
			Users.Hot.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeUsersHotMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \users\hot rest call. 
		/// It returns JsonResponse&lt;Users.Hot.Response&gt;
		/// Here comes request Comments:
		///<para>返回系统推荐的用户列表。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/users/hot.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Users.Hot.Response> ExecuteUsersHot(Users.Hot.Request request)
		{
			return ExecuteUsersHotAsync(request).Result;
		}
		
		
				
		/// <summary>
		/// Path\users\show
		/// </summary>
		JsonMethod<Users.Show.Request, Users.Show.Response> _executeUsersShowMethod;
		
		/// <summary>
		/// This is a async execution of \users\show rest call. 
		/// It returns JsonResponse&lt;Users.Show.Response&gt;
		/// Here comes request Comments:
		///<para>按用户ID或昵称返回用户资料以及用户的最新发布的一条微博消息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/users/show.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Users.Show.Response>> ExecuteUsersShowAsync (
			Users.Show.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _executeUsersShowMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		
		/// <summary>
		/// This is a sync execution of \users\show rest call. 
		/// It returns JsonResponse&lt;Users.Show.Response&gt;
		/// Here comes request Comments:
		///<para>按用户ID或昵称返回用户资料以及用户的最新发布的一条微博消息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/users/show.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Users.Show.Response> ExecuteUsersShow(Users.Show.Request request)
		{
			return ExecuteUsersShowAsync(request).Result;
		}
		
		
						
		JsonMethod<Emotions.Request, Stream> _requestEmotionsMethod;
		/// <summary>
		/// This is a async request of \emotions rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回新浪微博官方所有表情、魔法表情的相关信息。包括短语、表情类型、表情分类，是否热门等。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/emotions.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	false  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	false  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestEmotionsAsync (
			Emotions.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestEmotionsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \emotions rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回新浪微博官方所有表情、魔法表情的相关信息。包括短语、表情类型、表情分类，是否热门等。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/emotions.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	false  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	false  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestEmotions(Emotions.Request request)
		{
			return RequestEmotionsAsync(request).Result;
		}
		
				
		JsonMethod<Favorites.Request, Stream> _requestFavoritesMethod;
		/// <summary>
		/// This is a async request of \favorites rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回登录用户最近收藏的20条微博消息，和用户在主站上“我的收藏”页面看到的内容是一致的。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/favorites.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestFavoritesAsync (
			Favorites.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestFavoritesMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \favorites rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回登录用户最近收藏的20条微博消息，和用户在主站上“我的收藏”页面看到的内容是一致的。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/favorites.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestFavorites(Favorites.Request request)
		{
			return RequestFavoritesAsync(request).Result;
		}
		
				
		JsonMethod<Account.EndSession.Request, Stream> _requestAccountEndSessionMethod;
		/// <summary>
		/// This is a async request of \account\end_session rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>      清除已验证用户的session，退出登录，并将cookie设为null。主要用于widget等web应用场合。 </para>
		///<para>                                                                                       </para>
		///<para>URL                                                                                    </para>
		///<para>	http://api.t.sina.com.cn/account/end_session.(json|xml)                              </para>
		///<para>                                                                                       </para>
		///<para>HTTP请求方式                                                                           </para>
		///<para>	POST                                                                                 </para>
		///<para>                                                                                       </para>
		///<para>是否需要登录                                                                            </para>
		///<para>	true                                                                                 </para>
		///<para>关于授权机制，参见授权机制声明                                                           </para>
		///<para>                                                                                       </para>
		///<para>请求数限制                                                                              </para>
		///<para>	true                                                                                 </para>
		///<para>关于请求数限制，参见接口访问权限说明                                                     </para>
		///<para>
		///      
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestAccountEndSessionAsync (
			Account.EndSession.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestAccountEndSessionMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \account\end_session rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>      清除已验证用户的session，退出登录，并将cookie设为null。主要用于widget等web应用场合。 </para>
		///<para>                                                                                       </para>
		///<para>URL                                                                                    </para>
		///<para>	http://api.t.sina.com.cn/account/end_session.(json|xml)                              </para>
		///<para>                                                                                       </para>
		///<para>HTTP请求方式                                                                           </para>
		///<para>	POST                                                                                 </para>
		///<para>                                                                                       </para>
		///<para>是否需要登录                                                                            </para>
		///<para>	true                                                                                 </para>
		///<para>关于授权机制，参见授权机制声明                                                           </para>
		///<para>                                                                                       </para>
		///<para>请求数限制                                                                              </para>
		///<para>	true                                                                                 </para>
		///<para>关于请求数限制，参见接口访问权限说明                                                     </para>
		///<para>
		///      
		/// </summary>
		public JsonResponse<Stream> RequestAccountEndSession(Account.EndSession.Request request)
		{
			return RequestAccountEndSessionAsync(request).Result;
		}
		
				
		JsonMethod<Account.GetPrivacy.Request, Stream> _requestAccountGetPrivacyMethod;
		/// <summary>
		/// This is a async request of \account\get_privacy rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>获取隐私信息设置情况 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/account/get_privacy.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestAccountGetPrivacyAsync (
			Account.GetPrivacy.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestAccountGetPrivacyMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \account\get_privacy rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>获取隐私信息设置情况 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/account/get_privacy.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestAccountGetPrivacy(Account.GetPrivacy.Request request)
		{
			return RequestAccountGetPrivacyAsync(request).Result;
		}
		
				
		JsonMethod<Account.RateLimitStatus.Request, Stream> _requestAccountRateLimitStatusMethod;
		/// <summary>
		/// This is a async request of \account\rate_limit_status rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>获取API的访问频率限制。返回当前小时内还能访问的次数。频率限制是根据用户请求来做的限制，具体细节参见：接口访问权限说明。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/account/rate_limit_status.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestAccountRateLimitStatusAsync (
			Account.RateLimitStatus.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestAccountRateLimitStatusMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \account\rate_limit_status rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>获取API的访问频率限制。返回当前小时内还能访问的次数。频率限制是根据用户请求来做的限制，具体细节参见：接口访问权限说明。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/account/rate_limit_status.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestAccountRateLimitStatus(Account.RateLimitStatus.Request request)
		{
			return RequestAccountRateLimitStatusAsync(request).Result;
		}
		
				
		JsonMethod<Account.UpdatePrivacy.Request, Stream> _requestAccountUpdatePrivacyMethod;
		/// <summary>
		/// This is a async request of \account\update_privacy rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>设置隐私信息 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/account/update_privacy.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestAccountUpdatePrivacyAsync (
			Account.UpdatePrivacy.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestAccountUpdatePrivacyMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \account\update_privacy rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>设置隐私信息 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/account/update_privacy.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestAccountUpdatePrivacy(Account.UpdatePrivacy.Request request)
		{
			return RequestAccountUpdatePrivacyAsync(request).Result;
		}
		
				
		JsonMethod<Account.UpdateProfile.Request, Stream> _requestAccountUpdateProfileMethod;
		/// <summary>
		/// This is a async request of \account\update_profile rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>更新当前登录用户在新浪微博上的基本信息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/account/update_profile.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestAccountUpdateProfileAsync (
			Account.UpdateProfile.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestAccountUpdateProfileMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \account\update_profile rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>更新当前登录用户在新浪微博上的基本信息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/account/update_profile.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestAccountUpdateProfile(Account.UpdateProfile.Request request)
		{
			return RequestAccountUpdateProfileAsync(request).Result;
		}
		
				
		JsonMethod<Account.UpdateProfileImage.Request, Stream> _requestAccountUpdateProfileImageMethod;
		/// <summary>
		/// This is a async request of \account\update_profile_image rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>更新用户头像。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/account/update_profile_image.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para>注意事项:</para>
		///<para>	采用multipart/form-data编码方式提交，可以参考： Form-based File Upload in HTML</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestAccountUpdateProfileImageAsync (
			Account.UpdateProfileImage.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestAccountUpdateProfileImageMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \account\update_profile_image rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>更新用户头像。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/account/update_profile_image.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para>注意事项:</para>
		///<para>	采用multipart/form-data编码方式提交，可以参考： Form-based File Upload in HTML</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestAccountUpdateProfileImage(Account.UpdateProfileImage.Request request)
		{
			return RequestAccountUpdateProfileImageAsync(request).Result;
		}
		
				
		JsonMethod<Account.VerifyCredentials.Request, Stream> _requestAccountVerifyCredentialsMethod;
		/// <summary>
		/// This is a async request of \account\verify_credentials rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>验证用户是否已经开通微博服务。 </para>
		///<para>如果用户的新浪通行证身份验证成功，且用户已经开通微博则返回 http状态为 200，否则返回403错误。 </para>
		///<para>该接口除source以外，无其他参数。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/account/verify_credentials.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para>注意事项:</para>
		///<para>	若用户的新浪通行证身份验证成功，但未开通微博服务，则提示：40313:Error: invalid weibo user!。   若用户的新浪通行证身份验证失败，则提示：40302:Error: auth faild!</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestAccountVerifyCredentialsAsync (
			Account.VerifyCredentials.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestAccountVerifyCredentialsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \account\verify_credentials rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>验证用户是否已经开通微博服务。 </para>
		///<para>如果用户的新浪通行证身份验证成功，且用户已经开通微博则返回 http状态为 200，否则返回403错误。 </para>
		///<para>该接口除source以外，无其他参数。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/account/verify_credentials.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para>注意事项:</para>
		///<para>	若用户的新浪通行证身份验证成功，但未开通微博服务，则提示：40313:Error: invalid weibo user!。   若用户的新浪通行证身份验证失败，则提示：40302:Error: auth faild!</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestAccountVerifyCredentials(Account.VerifyCredentials.Request request)
		{
			return RequestAccountVerifyCredentialsAsync(request).Result;
		}
		
				
		JsonMethod<Blocks.Blocking.Request, Stream> _requestBlocksBlockingMethod;
		/// <summary>
		/// This is a async request of \blocks\blocking rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>分页输出当前登录用户的黑名单列表，包括黑名单内的用户详细信息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/blocks/blocking.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestBlocksBlockingAsync (
			Blocks.Blocking.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestBlocksBlockingMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \blocks\blocking rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>分页输出当前登录用户的黑名单列表，包括黑名单内的用户详细信息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/blocks/blocking.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestBlocksBlocking(Blocks.Blocking.Request request)
		{
			return RequestBlocksBlockingAsync(request).Result;
		}
		
				
		JsonMethod<Blocks.BlockingIds.Request, Stream> _requestBlocksBlockingIdsMethod;
		/// <summary>
		/// This is a async request of \blocks\blockingIds rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>分页输出当前登录用户黑名单中的用户ID列表。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/blocks/blocking/ids.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestBlocksBlockingIdsAsync (
			Blocks.BlockingIds.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestBlocksBlockingIdsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \blocks\blockingIds rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>分页输出当前登录用户黑名单中的用户ID列表。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/blocks/blocking/ids.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestBlocksBlockingIds(Blocks.BlockingIds.Request request)
		{
			return RequestBlocksBlockingIdsAsync(request).Result;
		}
		
				
		JsonMethod<Blocks.Create.Request, Stream> _requestBlocksCreateMethod;
		/// <summary>
		/// This is a async request of \blocks\create rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>将某用户加入登录用户的黑名单 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/blocks/create.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestBlocksCreateAsync (
			Blocks.Create.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestBlocksCreateMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \blocks\create rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>将某用户加入登录用户的黑名单 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/blocks/create.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestBlocksCreate(Blocks.Create.Request request)
		{
			return RequestBlocksCreateAsync(request).Result;
		}
		
				
		JsonMethod<Blocks.Destroy.Request, Stream> _requestBlocksDestroyMethod;
		/// <summary>
		/// This is a async request of \blocks\destroy rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>将某用户从当前登录用户的黑名单中移除 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/blocks/destroy.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestBlocksDestroyAsync (
			Blocks.Destroy.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestBlocksDestroyMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \blocks\destroy rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>将某用户从当前登录用户的黑名单中移除 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/blocks/destroy.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestBlocksDestroy(Blocks.Destroy.Request request)
		{
			return RequestBlocksDestroyAsync(request).Result;
		}
		
				
		JsonMethod<Blocks.Exists.Request, Stream> _requestBlocksExistsMethod;
		/// <summary>
		/// This is a async request of \blocks\exists rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>检测指定用户是否在登录用户的黑名单内。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/blocks/exists.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestBlocksExistsAsync (
			Blocks.Exists.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestBlocksExistsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \blocks\exists rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>检测指定用户是否在登录用户的黑名单内。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/blocks/exists.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestBlocksExists(Blocks.Exists.Request request)
		{
			return RequestBlocksExistsAsync(request).Result;
		}
		
				
		JsonMethod<Favorites.Create.Request, Stream> _requestFavoritesCreateMethod;
		/// <summary>
		/// This is a async request of \favorites\create rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>收藏一条微博消息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/favorites/create.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestFavoritesCreateAsync (
			Favorites.Create.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestFavoritesCreateMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \favorites\create rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>收藏一条微博消息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/favorites/create.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestFavoritesCreate(Favorites.Create.Request request)
		{
			return RequestFavoritesCreateAsync(request).Result;
		}
		
				
		JsonMethod<Favorites.Destroy.Request, Stream> _requestFavoritesDestroyMethod;
		/// <summary>
		/// This is a async request of \favorites\destroy rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>删除微博收藏。注意：只能删除自己收藏的信息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/favorites/destroy/:id.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestFavoritesDestroyAsync (
			Favorites.Destroy.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestFavoritesDestroyMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \favorites\destroy rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>删除微博收藏。注意：只能删除自己收藏的信息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/favorites/destroy/:id.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestFavoritesDestroy(Favorites.Destroy.Request request)
		{
			return RequestFavoritesDestroyAsync(request).Result;
		}
		
				
		JsonMethod<Favorites.DestroyBatch.Request, Stream> _requestFavoritesDestroyBatchMethod;
		/// <summary>
		/// This is a async request of \favorites\destroy_batch rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>删除微博收藏。注意：只能删除自己收藏的信息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/favorites/destroy_batch.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestFavoritesDestroyBatchAsync (
			Favorites.DestroyBatch.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestFavoritesDestroyBatchMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \favorites\destroy_batch rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>删除微博收藏。注意：只能删除自己收藏的信息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/favorites/destroy_batch.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestFavoritesDestroyBatch(Favorites.DestroyBatch.Request request)
		{
			return RequestFavoritesDestroyBatchAsync(request).Result;
		}
		
				
		JsonMethod<Friendships.Create.Request, Stream> _requestFriendshipsCreateMethod;
		/// <summary>
		/// This is a async request of \friendships\create rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>关注一个用户。关注成功则返回关注人的资料，目前的最多关注2000人。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/friendships/create.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestFriendshipsCreateAsync (
			Friendships.Create.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestFriendshipsCreateMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \friendships\create rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>关注一个用户。关注成功则返回关注人的资料，目前的最多关注2000人。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/friendships/create.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestFriendshipsCreate(Friendships.Create.Request request)
		{
			return RequestFriendshipsCreateAsync(request).Result;
		}
		
				
		JsonMethod<Friendships.Destroy.Request, Stream> _requestFriendshipsDestroyMethod;
		/// <summary>
		/// This is a async request of \friendships\destroy rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>取消对某用户的关注。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/friendships/destroy.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestFriendshipsDestroyAsync (
			Friendships.Destroy.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestFriendshipsDestroyMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \friendships\destroy rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>取消对某用户的关注。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/friendships/destroy.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestFriendshipsDestroy(Friendships.Destroy.Request request)
		{
			return RequestFriendshipsDestroyAsync(request).Result;
		}
		
				
		JsonMethod<Friendships.Exists.Request, Stream> _requestFriendshipsExistsMethod;
		/// <summary>
		/// This is a async request of \friendships\exists rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>查看用户A是否关注了用户B。如果用户A关注了用户B，则返回true，否则返回false。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/friendships/exists.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestFriendshipsExistsAsync (
			Friendships.Exists.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestFriendshipsExistsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \friendships\exists rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>查看用户A是否关注了用户B。如果用户A关注了用户B，则返回true，否则返回false。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/friendships/exists.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestFriendshipsExists(Friendships.Exists.Request request)
		{
			return RequestFriendshipsExistsAsync(request).Result;
		}
		
				
		JsonMethod<Friendships.Show.Request, Stream> _requestFriendshipsShowMethod;
		/// <summary>
		/// This is a async request of \friendships\show rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回两个用户关注关系的详细情况 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/friendships/show.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestFriendshipsShowAsync (
			Friendships.Show.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestFriendshipsShowMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \friendships\show rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回两个用户关注关系的详细情况 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/friendships/show.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestFriendshipsShow(Friendships.Show.Request request)
		{
			return RequestFriendshipsShowAsync(request).Result;
		}
		
				
		JsonMethod<ShortUrl.Expand.Request, Stream> _requestShortUrlExpandMethod;
		/// <summary>
		/// This is a async request of \short_url\expand rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>将一个或多个短链接还原成原始的长链接 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/short_url/expand.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	false  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestShortUrlExpandAsync (
			ShortUrl.Expand.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestShortUrlExpandMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \short_url\expand rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>将一个或多个短链接还原成原始的长链接 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/short_url/expand.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	false  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestShortUrlExpand(ShortUrl.Expand.Request request)
		{
			return RequestShortUrlExpandAsync(request).Result;
		}
		
				
		JsonMethod<ShortUrl.Shorten.Request, Stream> _requestShortUrlShortenMethod;
		/// <summary>
		/// This is a async request of \short_url\shorten rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>将一个或多个长链接转换成短链接 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/short_url/shorten.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	false  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestShortUrlShortenAsync (
			ShortUrl.Shorten.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestShortUrlShortenMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \short_url\shorten rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>将一个或多个长链接转换成短链接 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/short_url/shorten.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	false  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestShortUrlShorten(ShortUrl.Shorten.Request request)
		{
			return RequestShortUrlShortenAsync(request).Result;
		}
		
				
		JsonMethod<ShortUrl.Comment.Comments.Request, Stream> _requestShortUrlCommentCommentsMethod;
		/// <summary>
		/// This is a async request of \short_url\comment\comments rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>取得包含指定单个短链接的最新微博评论内容 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/short_url/comment/comments.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestShortUrlCommentCommentsAsync (
			ShortUrl.Comment.Comments.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestShortUrlCommentCommentsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \short_url\comment\comments rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>取得包含指定单个短链接的最新微博评论内容 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/short_url/comment/comments.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestShortUrlCommentComments(ShortUrl.Comment.Comments.Request request)
		{
			return RequestShortUrlCommentCommentsAsync(request).Result;
		}
		
				
		JsonMethod<ShortUrl.Comment.Counts.Request, Stream> _requestShortUrlCommentCountsMethod;
		/// <summary>
		/// This is a async request of \short_url\comment\counts rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>取得一个短链接在微博上的微博评论数 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/short_url/comment/counts.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	false  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestShortUrlCommentCountsAsync (
			ShortUrl.Comment.Counts.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestShortUrlCommentCountsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \short_url\comment\counts rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>取得一个短链接在微博上的微博评论数 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/short_url/comment/counts.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	false  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestShortUrlCommentCounts(ShortUrl.Comment.Counts.Request request)
		{
			return RequestShortUrlCommentCountsAsync(request).Result;
		}
		
				
		JsonMethod<ShortUrl.Share.Counts.Request, Stream> _requestShortUrlShareCountsMethod;
		/// <summary>
		/// This is a async request of \short_url\share\counts rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>取得一个短链接在微博上的微博分享数（包含原创和转发的微博） </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/short_url/share/counts.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	false  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestShortUrlShareCountsAsync (
			ShortUrl.Share.Counts.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestShortUrlShareCountsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \short_url\share\counts rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>取得一个短链接在微博上的微博分享数（包含原创和转发的微博） </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/short_url/share/counts.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	false  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestShortUrlShareCounts(ShortUrl.Share.Counts.Request request)
		{
			return RequestShortUrlShareCountsAsync(request).Result;
		}
		
				
		JsonMethod<ShortUrl.Share.Statuses.Request, Stream> _requestShortUrlShareStatusesMethod;
		/// <summary>
		/// This is a async request of \short_url\share\statuses rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>取得包含指定单个短链接的最新微博内容 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/short_url/share/statuses.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestShortUrlShareStatusesAsync (
			ShortUrl.Share.Statuses.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestShortUrlShareStatusesMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \short_url\share\statuses rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>取得包含指定单个短链接的最新微博内容 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/short_url/share/statuses.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestShortUrlShareStatuses(ShortUrl.Share.Statuses.Request request)
		{
			return RequestShortUrlShareStatusesAsync(request).Result;
		}
		
				
		JsonMethod<Socialgraph.FollowsIds.Request, Stream> _requestSocialgraphFollowsIdsMethod;
		/// <summary>
		/// This is a async request of \socialgraph\followsIds rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回用户的粉丝用户ID列表 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/followers/ids.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestSocialgraphFollowsIdsAsync (
			Socialgraph.FollowsIds.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestSocialgraphFollowsIdsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \socialgraph\followsIds rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回用户的粉丝用户ID列表 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/followers/ids.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestSocialgraphFollowsIds(Socialgraph.FollowsIds.Request request)
		{
			return RequestSocialgraphFollowsIdsAsync(request).Result;
		}
		
				
		JsonMethod<Socialgraph.FriendsIds.Request, Stream> _requestSocialgraphFriendsIdsMethod;
		/// <summary>
		/// This is a async request of \socialgraph\friendsIds rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回用户关注的一组用户的ID列表 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/friends/ids.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestSocialgraphFriendsIdsAsync (
			Socialgraph.FriendsIds.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestSocialgraphFriendsIdsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \socialgraph\friendsIds rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回用户关注的一组用户的ID列表 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/friends/ids.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestSocialgraphFriendsIds(Socialgraph.FriendsIds.Request request)
		{
			return RequestSocialgraphFriendsIdsAsync(request).Result;
		}
		
				
		JsonMethod<Statuses.Comment.Request, Stream> _requestStatusesCommentMethod;
		/// <summary>
		/// This is a async request of \statuses\comment rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>对一条微博信息进行评论。请求必须用POST方式提交。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/comment.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestStatusesCommentAsync (
			Statuses.Comment.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestStatusesCommentMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \statuses\comment rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>对一条微博信息进行评论。请求必须用POST方式提交。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/comment.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestStatusesComment(Statuses.Comment.Request request)
		{
			return RequestStatusesCommentAsync(request).Result;
		}
		
				
		JsonMethod<Statuses.Comments.Request, Stream> _requestStatusesCommentsMethod;
		/// <summary>
		/// This is a async request of \statuses\comments rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>根据微博消息ID返回某条微博消息的评论列表 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/comments.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestStatusesCommentsAsync (
			Statuses.Comments.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestStatusesCommentsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \statuses\comments rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>根据微博消息ID返回某条微博消息的评论列表 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/comments.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestStatusesComments(Statuses.Comments.Request request)
		{
			return RequestStatusesCommentsAsync(request).Result;
		}
		
				
		JsonMethod<Statuses.CommentsByMe.Request, Stream> _requestStatusesCommentsByMeMethod;
		/// <summary>
		/// This is a async request of \statuses\comments_by_me rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>获取当前用户发出的评论 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/comments_by_me.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestStatusesCommentsByMeAsync (
			Statuses.CommentsByMe.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestStatusesCommentsByMeMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \statuses\comments_by_me rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>获取当前用户发出的评论 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/comments_by_me.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestStatusesCommentsByMe(Statuses.CommentsByMe.Request request)
		{
			return RequestStatusesCommentsByMeAsync(request).Result;
		}
		
				
		JsonMethod<Statuses.CommentsTimeline.Request, Stream> _requestStatusesCommentsTimelineMethod;
		/// <summary>
		/// This is a async request of \statuses\comments_timeline rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回最新n条发送及收到的评论。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/comments_timeline.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestStatusesCommentsTimelineAsync (
			Statuses.CommentsTimeline.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestStatusesCommentsTimelineMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \statuses\comments_timeline rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回最新n条发送及收到的评论。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/comments_timeline.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestStatusesCommentsTimeline(Statuses.CommentsTimeline.Request request)
		{
			return RequestStatusesCommentsTimelineAsync(request).Result;
		}
		
				
		JsonMethod<Statuses.CommentsToMe.Request, Stream> _requestStatusesCommentsToMeMethod;
		/// <summary>
		/// This is a async request of \statuses\comments_to_me rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回当前登录用户收到的评论 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/comments_to_me.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestStatusesCommentsToMeAsync (
			Statuses.CommentsToMe.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestStatusesCommentsToMeMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \statuses\comments_to_me rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回当前登录用户收到的评论 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/comments_to_me.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestStatusesCommentsToMe(Statuses.CommentsToMe.Request request)
		{
			return RequestStatusesCommentsToMeAsync(request).Result;
		}
		
				
		JsonMethod<Statuses.CommentDestroy.Request, Stream> _requestStatusesCommentDestroyMethod;
		/// <summary>
		/// This is a async request of \statuses\comment_destroy rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>删除评论。注意：只能删除登录用户自己发布的评论，不可以删除其他人的评论。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/comment_destroy/:id.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestStatusesCommentDestroyAsync (
			Statuses.CommentDestroy.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestStatusesCommentDestroyMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \statuses\comment_destroy rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>删除评论。注意：只能删除登录用户自己发布的评论，不可以删除其他人的评论。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/comment_destroy/:id.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestStatusesCommentDestroy(Statuses.CommentDestroy.Request request)
		{
			return RequestStatusesCommentDestroyAsync(request).Result;
		}
		
				
		JsonMethod<Statuses.CommentDestroyBatch.Request, Stream> _requestStatusesCommentDestroyBatchMethod;
		/// <summary>
		/// This is a async request of \statuses\comment_destroy_batch rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>批量删除评论。注意：只能删除登录用户自己发布的评论，不可以删除其他人的评论。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/comment/destroy_batch.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestStatusesCommentDestroyBatchAsync (
			Statuses.CommentDestroyBatch.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestStatusesCommentDestroyBatchMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \statuses\comment_destroy_batch rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>批量删除评论。注意：只能删除登录用户自己发布的评论，不可以删除其他人的评论。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/comment/destroy_batch.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestStatusesCommentDestroyBatch(Statuses.CommentDestroyBatch.Request request)
		{
			return RequestStatusesCommentDestroyBatchAsync(request).Result;
		}
		
				
		JsonMethod<Statuses.Counts.Request, Stream> _requestStatusesCountsMethod;
		/// <summary>
		/// This is a async request of \statuses\counts rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>批量获取n条微博消息的评论数和转发数。一次请求最多可以获取20条微博消息的评论数和转发数 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/counts.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestStatusesCountsAsync (
			Statuses.Counts.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestStatusesCountsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \statuses\counts rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>批量获取n条微博消息的评论数和转发数。一次请求最多可以获取20条微博消息的评论数和转发数 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/counts.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestStatusesCounts(Statuses.Counts.Request request)
		{
			return RequestStatusesCountsAsync(request).Result;
		}
		
				
		JsonMethod<Statuses.Destroy.Request, Stream> _requestStatusesDestroyMethod;
		/// <summary>
		/// This is a async request of \statuses\destroy rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>根据ID删除微博消息。注意：只能删除自己发布的微博消息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/destroy/:id.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestStatusesDestroyAsync (
			Statuses.Destroy.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestStatusesDestroyMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \statuses\destroy rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>根据ID删除微博消息。注意：只能删除自己发布的微博消息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/destroy/:id.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestStatusesDestroy(Statuses.Destroy.Request request)
		{
			return RequestStatusesDestroyAsync(request).Result;
		}
		
				
		JsonMethod<Statuses.Followers.Request, Stream> _requestStatusesFollowersMethod;
		/// <summary>
		/// This is a async request of \statuses\followers rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>获取用户粉丝列表及每个粉丝的最新一条微博，返回结果按粉丝的关注时间倒序排列，最新关注的粉丝排在最前面。每次返回20个,通过cursor参数来取得多于20的粉丝。注意目前接口最多只返回5000个粉丝。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/followers.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	false  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestStatusesFollowersAsync (
			Statuses.Followers.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestStatusesFollowersMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \statuses\followers rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>获取用户粉丝列表及每个粉丝的最新一条微博，返回结果按粉丝的关注时间倒序排列，最新关注的粉丝排在最前面。每次返回20个,通过cursor参数来取得多于20的粉丝。注意目前接口最多只返回5000个粉丝。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/followers.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	false  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestStatusesFollowers(Statuses.Followers.Request request)
		{
			return RequestStatusesFollowersAsync(request).Result;
		}
		
				
		JsonMethod<Statuses.Friends.Request, Stream> _requestStatusesFriendsMethod;
		/// <summary>
		/// This is a async request of \statuses\friends rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>获取用户关注列表及每个关注用户的最新一条微博，返回结果按关注时间倒序排列，最新关注的用户排在最前面。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/friends.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestStatusesFriendsAsync (
			Statuses.Friends.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestStatusesFriendsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \statuses\friends rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>获取用户关注列表及每个关注用户的最新一条微博，返回结果按关注时间倒序排列，最新关注的用户排在最前面。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/friends.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestStatusesFriends(Statuses.Friends.Request request)
		{
			return RequestStatusesFriendsAsync(request).Result;
		}
		
				
		JsonMethod<Statuses.FriendsTimeline.Request, Stream> _requestStatusesFriendsTimelineMethod;
		/// <summary>
		/// This is a async request of \statuses\friends_timeline rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>获取当前登录用户及其所关注用户的最新微博消息。和用户登录 http://t.sina.com.cn 后在“我的首页”中看到的内容相同。</para>
		///<para>别名statuses/home_timeline </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/friends_timeline.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestStatusesFriendsTimelineAsync (
			Statuses.FriendsTimeline.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestStatusesFriendsTimelineMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \statuses\friends_timeline rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>获取当前登录用户及其所关注用户的最新微博消息。和用户登录 http://t.sina.com.cn 后在“我的首页”中看到的内容相同。</para>
		///<para>别名statuses/home_timeline </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/friends_timeline.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestStatusesFriendsTimeline(Statuses.FriendsTimeline.Request request)
		{
			return RequestStatusesFriendsTimelineAsync(request).Result;
		}
		
				
		JsonMethod<Statuses.Mentions.Request, Stream> _requestStatusesMentionsMethod;
		/// <summary>
		/// This is a async request of \statuses\mentions rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回最新n条提到登录用户的微博消息（即包含@username的微博消息） </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/mentions.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestStatusesMentionsAsync (
			Statuses.Mentions.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestStatusesMentionsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \statuses\mentions rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回最新n条提到登录用户的微博消息（即包含@username的微博消息） </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/mentions.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestStatusesMentions(Statuses.Mentions.Request request)
		{
			return RequestStatusesMentionsAsync(request).Result;
		}
		
				
		JsonMethod<Statuses.PublicTimeline.Request, Stream> _requestStatusesPublicTimelineMethod;
		/// <summary>
		/// This is a async request of \statuses\public_timeline rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回最新的20条公共微博。返回结果非完全实时，最长会缓存60秒 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/public_timeline.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	false  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestStatusesPublicTimelineAsync (
			Statuses.PublicTimeline.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestStatusesPublicTimelineMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \statuses\public_timeline rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回最新的20条公共微博。返回结果非完全实时，最长会缓存60秒 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/public_timeline.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	false  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestStatusesPublicTimeline(Statuses.PublicTimeline.Request request)
		{
			return RequestStatusesPublicTimelineAsync(request).Result;
		}
		
				
		JsonMethod<Statuses.Reply.Request, Stream> _requestStatusesReplyMethod;
		/// <summary>
		/// This is a async request of \statuses\reply rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>回复评论。请求必须用POST方式提交。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/reply.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestStatusesReplyAsync (
			Statuses.Reply.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestStatusesReplyMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \statuses\reply rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>回复评论。请求必须用POST方式提交。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/reply.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestStatusesReply(Statuses.Reply.Request request)
		{
			return RequestStatusesReplyAsync(request).Result;
		}
		
				
		JsonMethod<Statuses.Repost.Request, Stream> _requestStatusesRepostMethod;
		/// <summary>
		/// This is a async request of \statuses\repost rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>转发一条微博消息。请求必须用POST方式提交。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/repost.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestStatusesRepostAsync (
			Statuses.Repost.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestStatusesRepostMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \statuses\repost rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>转发一条微博消息。请求必须用POST方式提交。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/repost.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestStatusesRepost(Statuses.Repost.Request request)
		{
			return RequestStatusesRepostAsync(request).Result;
		}
		
				
		JsonMethod<Statuses.RepostByMe.Request, Stream> _requestStatusesRepostByMeMethod;
		/// <summary>
		/// This is a async request of \statuses\repost_by_me rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>获取用户最新转发的n条微博消息 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/repost_by_me.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestStatusesRepostByMeAsync (
			Statuses.RepostByMe.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestStatusesRepostByMeMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \statuses\repost_by_me rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>获取用户最新转发的n条微博消息 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/repost_by_me.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestStatusesRepostByMe(Statuses.RepostByMe.Request request)
		{
			return RequestStatusesRepostByMeAsync(request).Result;
		}
		
				
		JsonMethod<Statuses.RepostTimeline.Request, Stream> _requestStatusesRepostTimelineMethod;
		/// <summary>
		/// This is a async request of \statuses\repost_timeline rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回一条原创微博消息的最新n条转发微博消息。本接口无法对非原创微博进行查询。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/repost_timeline.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestStatusesRepostTimelineAsync (
			Statuses.RepostTimeline.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestStatusesRepostTimelineMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \statuses\repost_timeline rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回一条原创微博消息的最新n条转发微博消息。本接口无法对非原创微博进行查询。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/repost_timeline.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestStatusesRepostTimeline(Statuses.RepostTimeline.Request request)
		{
			return RequestStatusesRepostTimelineAsync(request).Result;
		}
		
				
		JsonMethod<Statuses.ResetCount.Request, Stream> _requestStatusesResetCountMethod;
		/// <summary>
		/// This is a async request of \statuses\reset_count rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>将当前登录用户的某种新消息的未读数为0。可以清零的计数类别有：1. 评论数，2. @me数，3. 私信数，4. 关注数 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/reset_count.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	false  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestStatusesResetCountAsync (
			Statuses.ResetCount.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestStatusesResetCountMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \statuses\reset_count rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>将当前登录用户的某种新消息的未读数为0。可以清零的计数类别有：1. 评论数，2. @me数，3. 私信数，4. 关注数 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/reset_count.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	false  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestStatusesResetCount(Statuses.ResetCount.Request request)
		{
			return RequestStatusesResetCountAsync(request).Result;
		}
		
				
		JsonMethod<Statuses.Show.Request, Stream> _requestStatusesShowMethod;
		/// <summary>
		/// This is a async request of \statuses\show rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>根据ID获取单条微博消息，以及该微博消息的作者信息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/show/:id.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestStatusesShowAsync (
			Statuses.Show.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestStatusesShowMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \statuses\show rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>根据ID获取单条微博消息，以及该微博消息的作者信息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/show/:id.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestStatusesShow(Statuses.Show.Request request)
		{
			return RequestStatusesShowAsync(request).Result;
		}
		
				
		JsonMethod<Statuses.Unread.Request, Stream> _requestStatusesUnreadMethod;
		/// <summary>
		/// This is a async request of \statuses\unread rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>获取当前用户Web主站未读消息数，包括： </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/unread.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestStatusesUnreadAsync (
			Statuses.Unread.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestStatusesUnreadMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \statuses\unread rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>获取当前用户Web主站未读消息数，包括： </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/unread.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestStatusesUnread(Statuses.Unread.Request request)
		{
			return RequestStatusesUnreadAsync(request).Result;
		}
		
				
		JsonMethod<Statuses.Update.Request, Stream> _requestStatusesUpdateMethod;
		/// <summary>
		/// This is a async request of \statuses\update rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>发布一条微博信息。也可以同时转发某条微博。请求必须用POST方式提交。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/update.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestStatusesUpdateAsync (
			Statuses.Update.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestStatusesUpdateMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \statuses\update rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>发布一条微博信息。也可以同时转发某条微博。请求必须用POST方式提交。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/update.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestStatusesUpdate(Statuses.Update.Request request)
		{
			return RequestStatusesUpdateAsync(request).Result;
		}
		
				
		JsonMethod<Statuses.Upload.Request, Stream> _requestStatusesUploadMethod;
		/// <summary>
		/// This is a async request of \statuses\upload rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>发表带图片的微博。必须用POST方式提交pic参数，且Content-Type必须设置为multipart/form-data。图片大小<5M。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/upload.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestStatusesUploadAsync (
			Statuses.Upload.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestStatusesUploadMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \statuses\upload rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>发表带图片的微博。必须用POST方式提交pic参数，且Content-Type必须设置为multipart/form-data。图片大小<5M。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/upload.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestStatusesUpload(Statuses.Upload.Request request)
		{
			return RequestStatusesUploadAsync(request).Result;
		}
		
				
		JsonMethod<Statuses.UserTimeline.Request, Stream> _requestStatusesUserTimelineMethod;
		/// <summary>
		/// This is a async request of \statuses\user_timeline rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回用户最新发表的微博消息列表。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/user_timeline.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestStatusesUserTimelineAsync (
			Statuses.UserTimeline.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestStatusesUserTimelineMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \statuses\user_timeline rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回用户最新发表的微博消息列表。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/statuses/user_timeline.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestStatusesUserTimeline(Statuses.UserTimeline.Request request)
		{
			return RequestStatusesUserTimelineAsync(request).Result;
		}
		
				
		JsonMethod<Tags.Create.Request, Stream> _requestTagsCreateMethod;
		/// <summary>
		/// This is a async request of \tags\create rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>为当前登录用户添加新的用户标签 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/tags/create.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestTagsCreateAsync (
			Tags.Create.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestTagsCreateMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \tags\create rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>为当前登录用户添加新的用户标签 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/tags/create.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestTagsCreate(Tags.Create.Request request)
		{
			return RequestTagsCreateAsync(request).Result;
		}
		
				
		JsonMethod<Tags.Destroy.Request, Stream> _requestTagsDestroyMethod;
		/// <summary>
		/// This is a async request of \tags\destroy rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>删除标签 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/tags/destroy.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestTagsDestroyAsync (
			Tags.Destroy.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestTagsDestroyMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \tags\destroy rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>删除标签 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/tags/destroy.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestTagsDestroy(Tags.Destroy.Request request)
		{
			return RequestTagsDestroyAsync(request).Result;
		}
		
				
		JsonMethod<Tags.DestroyBatch.Request, Stream> _requestTagsDestroyBatchMethod;
		/// <summary>
		/// This is a async request of \tags\destroy_batch rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>删除一组标签 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/tags/destroy_batch.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestTagsDestroyBatchAsync (
			Tags.DestroyBatch.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestTagsDestroyBatchMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \tags\destroy_batch rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>删除一组标签 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/tags/destroy_batch.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST/DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestTagsDestroyBatch(Tags.DestroyBatch.Request request)
		{
			return RequestTagsDestroyBatchAsync(request).Result;
		}
		
				
		JsonMethod<Tags.Suggestions.Request, Stream> _requestTagsSuggestionsMethod;
		/// <summary>
		/// This is a async request of \tags\suggestions rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>获取当前登录用户感兴趣的推荐标签列表 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/tags/suggestions.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestTagsSuggestionsAsync (
			Tags.Suggestions.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestTagsSuggestionsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \tags\suggestions rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>获取当前登录用户感兴趣的推荐标签列表 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/tags/suggestions.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestTagsSuggestions(Tags.Suggestions.Request request)
		{
			return RequestTagsSuggestionsAsync(request).Result;
		}
		
				
		JsonMethod<Tags.Tags.Request, Stream> _requestTagsTagsMethod;
		/// <summary>
		/// This is a async request of \tags\tags rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回指定用户的标签列表 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/tags.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestTagsTagsAsync (
			Tags.Tags.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestTagsTagsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \tags\tags rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回指定用户的标签列表 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/tags.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestTagsTags(Tags.Tags.Request request)
		{
			return RequestTagsTagsAsync(request).Result;
		}
		
				
		JsonMethod<Trends.Daily.Request, Stream> _requestTrendsDailyMethod;
		/// <summary>
		/// This is a async request of \trends\daily rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回最近一天内的热门话题。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/trends/daily.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestTrendsDailyAsync (
			Trends.Daily.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestTrendsDailyMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \trends\daily rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回最近一天内的热门话题。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/trends/daily.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestTrendsDaily(Trends.Daily.Request request)
		{
			return RequestTrendsDailyAsync(request).Result;
		}
		
				
		JsonMethod<Trends.Destroy.Request, Stream> _requestTrendsDestroyMethod;
		/// <summary>
		/// This is a async request of \trends\destroy rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>取消对某话题的关注。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/trends/destroy.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestTrendsDestroyAsync (
			Trends.Destroy.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestTrendsDestroyMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \trends\destroy rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>取消对某话题的关注。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/trends/destroy.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	DELETE</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestTrendsDestroy(Trends.Destroy.Request request)
		{
			return RequestTrendsDestroyAsync(request).Result;
		}
		
				
		JsonMethod<Trends.Follow.Request, Stream> _requestTrendsFollowMethod;
		/// <summary>
		/// This is a async request of \trends\follow rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>关注某话题。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/trends/follow.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestTrendsFollowAsync (
			Trends.Follow.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestTrendsFollowMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \trends\follow rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>关注某话题。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/trends/follow.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestTrendsFollow(Trends.Follow.Request request)
		{
			return RequestTrendsFollowAsync(request).Result;
		}
		
				
		JsonMethod<Trends.Hourly.Request, Stream> _requestTrendsHourlyMethod;
		/// <summary>
		/// This is a async request of \trends\hourly rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回最近一小时内的热门话题。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/trends/hourly.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestTrendsHourlyAsync (
			Trends.Hourly.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestTrendsHourlyMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \trends\hourly rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回最近一小时内的热门话题。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/trends/hourly.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestTrendsHourly(Trends.Hourly.Request request)
		{
			return RequestTrendsHourlyAsync(request).Result;
		}
		
				
		JsonMethod<Trends.Statuses.Request, Stream> _requestTrendsStatusesMethod;
		/// <summary>
		/// This is a async request of \trends\statuses rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>获取某话题下的微博消息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/trends/statuses.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestTrendsStatusesAsync (
			Trends.Statuses.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestTrendsStatusesMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \trends\statuses rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>获取某话题下的微博消息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/trends/statuses.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestTrendsStatuses(Trends.Statuses.Request request)
		{
			return RequestTrendsStatusesAsync(request).Result;
		}
		
				
		JsonMethod<Trends.Trends.Request, Stream> _requestTrendsTrendsMethod;
		/// <summary>
		/// This is a async request of \trends\trends rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>获取某用户的话题。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/trends.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestTrendsTrendsAsync (
			Trends.Trends.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestTrendsTrendsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \trends\trends rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>获取某用户的话题。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/trends.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestTrendsTrends(Trends.Trends.Request request)
		{
			return RequestTrendsTrendsAsync(request).Result;
		}
		
				
		JsonMethod<Trends.Weekly.Request, Stream> _requestTrendsWeeklyMethod;
		/// <summary>
		/// This is a async request of \trends\weekly rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回最近一周内的热门话题。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/trends/weekly.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestTrendsWeeklyAsync (
			Trends.Weekly.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestTrendsWeeklyMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \trends\weekly rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回最近一周内的热门话题。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/trends/weekly.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestTrendsWeekly(Trends.Weekly.Request request)
		{
			return RequestTrendsWeeklyAsync(request).Result;
		}
		
				
		JsonMethod<User.Friends.UpdateRemark.Request, Stream> _requestUserFriendsUpdateRemarkMethod;
		/// <summary>
		/// This is a async request of \user\friends\update_remark rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>更新当前登录用户所关注的某个好友的备注信息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/user/friends/update_remark.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestUserFriendsUpdateRemarkAsync (
			User.Friends.UpdateRemark.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestUserFriendsUpdateRemarkMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \user\friends\update_remark rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>更新当前登录用户所关注的某个好友的备注信息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/user/friends/update_remark.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	POST</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestUserFriendsUpdateRemark(User.Friends.UpdateRemark.Request request)
		{
			return RequestUserFriendsUpdateRemarkAsync(request).Result;
		}
		
				
		JsonMethod<Users.Hot.Request, Stream> _requestUsersHotMethod;
		/// <summary>
		/// This is a async request of \users\hot rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回系统推荐的用户列表。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/users/hot.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestUsersHotAsync (
			Users.Hot.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestUsersHotMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \users\hot rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回系统推荐的用户列表。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/users/hot.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestUsersHot(Users.Hot.Request request)
		{
			return RequestUsersHotAsync(request).Result;
		}
		
				
		JsonMethod<Users.Show.Request, Stream> _requestUsersShowMethod;
		/// <summary>
		/// This is a async request of \users\show rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>按用户ID或昵称返回用户资料以及用户的最新发布的一条微博消息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/users/show.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestUsersShowAsync (
			Users.Show.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestUsersShowMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \users\show rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>按用户ID或昵称返回用户资料以及用户的最新发布的一条微博消息。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/users/show.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestUsersShow(Users.Show.Request request)
		{
			return RequestUsersShowAsync(request).Result;
		}
		
				
		JsonMethod<Users.Suggestions.Request, Stream> _requestUsersSuggestionsMethod;
		/// <summary>
		/// This is a async request of \users\suggestions rest call. 
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回当前用户可能感兴趣的用户。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/users/suggestions.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public async Task<JsonResponse<Stream>> RequestUsersSuggestionsAsync (
			Users.Suggestions.Request request,
			CancellationToken cancellationToken =default(CancellationToken),
			IProgress<ProgressReport> progress=null 
			)			
		{
			return await _requestUsersSuggestionsMethod.GetResponseAsync(request, cancellationToken, progress);
		}
		/// <summary>
		/// This is a sync request of \users\suggestions rest call.
		///It returns JsonResponse&lt;Stream&gt;
		/// Here comes request Comments:
		///<para>返回当前用户可能感兴趣的用户。 </para>
		///<para>URL:</para>
		///<para>	http://api.t.sina.com.cn/users/suggestions.(json|xml)</para>
		///<para>支持格式:</para>
		///<para>	XML/JSON</para>
		///<para>HTTP请求方式:</para>
		///<para>	GET</para>
		///<para>是否需要登录:</para>
		///<para>	true  关于授权机制，参见授权机制声明</para>
		///<para>请求数限制:</para>
		///<para>	true  关于请求数限制，参见接口访问权限说明</para>
		///<para></para>
		/// </summary>
		public JsonResponse<Stream> RequestUsersSuggestions(Users.Suggestions.Request request)
		{
			return RequestUsersSuggestionsAsync(request).Result;
		}
		
				
	}

}

 